Merge release/dev17.13 to main

eng/common/templates-official/steps/get-delegation-sas.yml

@@ -1,7 +1,52 @@
+parameters:
+- name: federatedServiceConnection
+  type: string
+- name: outputVariableName
+  type: string
+- name: expiryInHours
+  type: number
+  default: 1
+- name: base64Encode
+  type: boolean
+  default: false
+- name: storageAccount
+  type: string
+- name: container
+  type: string
+- name: permissions
+  type: string
+  default: 'rl'
+
 steps:
-- template: /eng/common/core-templates/steps/get-delegation-sas.yml
-  parameters:
-    is1ESPipeline: true
+- task: AzureCLI@2
+  displayName: 'Generate delegation SAS Token for ${{ parameters.storageAccount }}/${{ parameters.container }}'
+  inputs:
+    azureSubscription: ${{ parameters.federatedServiceConnection }}
+    scriptType: 'pscore'
+    scriptLocation: 'inlineScript'
+    inlineScript: |
+      # Calculate the expiration of the SAS token and convert to UTC
+      $expiry = (Get-Date).AddHours(${{ parameters.expiryInHours }}).ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ")
+
+      # Temporarily work around a helix issue where SAS tokens with / in them will cause incorrect downloads
+      # of correlation payloads. https://github.com/dotnet/dnceng/issues/3484
+      $sas = ""
+      do {
+        $sas = az storage container generate-sas --account-name ${{ parameters.storageAccount }} --name ${{ parameters.container }} --permissions ${{ parameters.permissions }} --expiry $expiry --auth-mode login --as-user -o tsv
+        if ($LASTEXITCODE -ne 0) {
+          Write-Error "Failed to generate SAS token."
+          exit 1
+        }
+      } while($sas.IndexOf('/') -ne -1)
+
+      if ($LASTEXITCODE -ne 0) {
+        Write-Error "Failed to generate SAS token."
+        exit 1
+      }
+
+      if ('${{ parameters.base64Encode }}' -eq 'true') {
+        $sas = [Convert]::ToBase64String([System.Text.Encoding]::UTF8.GetBytes($sas))
+      }
 
-    ${{ each parameter in parameters }}:
-      ${{ parameter.key }}: ${{ parameter.value }}
+      Write-Host "Setting '${{ parameters.outputVariableName }}' with the access token value"
+      Write-Host "##vso[task.setvariable variable=${{ parameters.outputVariableName }};issecret=true]$sas"

eng/common/templates/steps/get-delegation-sas.yml

@@ -1,7 +1,52 @@
+parameters:
+- name: federatedServiceConnection
+  type: string
+- name: outputVariableName
+  type: string
+- name: expiryInHours
+  type: number
+  default: 1
+- name: base64Encode
+  type: boolean
+  default: false
+- name: storageAccount
+  type: string
+- name: container
+  type: string
+- name: permissions
+  type: string
+  default: 'rl'
+
 steps:
-- template: /eng/common/core-templates/steps/get-delegation-sas.yml
-  parameters:
-    is1ESPipeline: false
+- task: AzureCLI@2
+  displayName: 'Generate delegation SAS Token for ${{ parameters.storageAccount }}/${{ parameters.container }}'
+  inputs:
+    azureSubscription: ${{ parameters.federatedServiceConnection }}
+    scriptType: 'pscore'
+    scriptLocation: 'inlineScript'
+    inlineScript: |
+      # Calculate the expiration of the SAS token and convert to UTC
+      $expiry = (Get-Date).AddHours(${{ parameters.expiryInHours }}).ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ")
+
+      # Temporarily work around a helix issue where SAS tokens with / in them will cause incorrect downloads
+      # of correlation payloads. https://github.com/dotnet/dnceng/issues/3484
+      $sas = ""
+      do {
+        $sas = az storage container generate-sas --account-name ${{ parameters.storageAccount }} --name ${{ parameters.container }} --permissions ${{ parameters.permissions }} --expiry $expiry --auth-mode login --as-user -o tsv
+        if ($LASTEXITCODE -ne 0) {
+          Write-Error "Failed to generate SAS token."
+          exit 1
+        }
+      } while($sas.IndexOf('/') -ne -1)
+
+      if ($LASTEXITCODE -ne 0) {
+        Write-Error "Failed to generate SAS token."
+        exit 1
+      }
+
+      if ('${{ parameters.base64Encode }}' -eq 'true') {
+        $sas = [Convert]::ToBase64String([System.Text.Encoding]::UTF8.GetBytes($sas))
+      }
 
-    ${{ each parameter in parameters }}:
-      ${{ parameter.key }}: ${{ parameter.value }}
+      Write-Host "Setting '${{ parameters.outputVariableName }}' with the access token value"
+      Write-Host "##vso[task.setvariable variable=${{ parameters.outputVariableName }};issecret=true]$sas"

src/Compilers/Core/MSBuildTask/Microsoft.Managed.Core.targets

@@ -319,8 +319,11 @@
 
     CompilerGeneratedFilesOutputPath controls the location the files will be output to.
     The compiler will not emit any generated files when the path is empty, and defaults to a /generated directory in $(IntermediateOutputPath) if $(IntermediateOutputPath) has a value.
+    A relative path is considered relative to the project directory.
+
     EmitCompilerGeneratedFiles allows the user to control if anything is emitted by clearing the property when not true.
     When EmitCompilerGeneratedFiles is true, we ensure that CompilerGeneatedFilesOutputPath has a value and issue a warning if not.
+
     We will create CompilerGeneratedFilesOutputPath if it does not exist.
     -->
   <PropertyGroup>

src/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.StateManager.HostStates.cs

@@ -6,6 +6,7 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
+using Microsoft.CodeAnalysis.PooledObjects;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Diagnostics.EngineV2
@@ -31,19 +32,76 @@ public IEnumerable<StateSet> GetAllHostStateSets()
 
             private HostAnalyzerStateSets GetOrCreateHostStateSets(Project project, ProjectAnalyzerStateSets projectStateSets)
             {
-                var key = new HostAnalyzerStateSetKey(project.Language, project.Solution.SolutionState.Analyzers.HostAnalyzerReferences);
-                var hostStateSets = ImmutableInterlocked.GetOrAdd(ref _hostAnalyzerStateMap, key, CreateLanguageSpecificAnalyzerMap, project.Solution.SolutionState.Analyzers);
+                var key = new HostAnalyzerStateSetKey(project.Language, project.State.HasSdkCodeStyleAnalyzers, project.Solution.SolutionState.Analyzers.HostAnalyzerReferences);
+                // Some Host Analyzers may need to be treated as Project Analyzers so that they do not have access to the
+                // Host fallback options. These ids will be used when building up the Host and Project analyzer collections.
+                var referenceIdsToRedirect = GetReferenceIdsToRedirectAsProjectAnalyzers(project);
+                var hostStateSets = ImmutableInterlocked.GetOrAdd(ref _hostAnalyzerStateMap, key, CreateLanguageSpecificAnalyzerMap, (project.Solution.SolutionState.Analyzers, referenceIdsToRedirect));
                 return hostStateSets.WithExcludedAnalyzers(projectStateSets.SkippedAnalyzersInfo.SkippedAnalyzers);
 
-                static HostAnalyzerStateSets CreateLanguageSpecificAnalyzerMap(HostAnalyzerStateSetKey arg, HostDiagnosticAnalyzers hostAnalyzers)
+                static HostAnalyzerStateSets CreateLanguageSpecificAnalyzerMap(HostAnalyzerStateSetKey arg, (HostDiagnosticAnalyzers HostAnalyzers, ImmutableHashSet<object> ReferenceIdsToRedirect) state)
                 {
                     var language = arg.Language;
-                    var analyzersPerReference = hostAnalyzers.GetOrCreateHostDiagnosticAnalyzersPerReference(language);
+                    var analyzersPerReference = state.HostAnalyzers.GetOrCreateHostDiagnosticAnalyzersPerReference(language);
 
-                    var analyzerMap = CreateStateSetMap(language, [], analyzersPerReference.Values, includeWorkspacePlaceholderAnalyzers: true);
+                    var (hostAnalyzerCollection, projectAnalyzerCollection) = GetAnalyzerCollections(analyzersPerReference, state.ReferenceIdsToRedirect);
+                    var analyzerMap = CreateStateSetMap(language, projectAnalyzerCollection, hostAnalyzerCollection, includeWorkspacePlaceholderAnalyzers: true);
 
                     return new HostAnalyzerStateSets(analyzerMap);
                 }
+
+                static (IEnumerable<ImmutableArray<DiagnosticAnalyzer>> HostAnalyzerCollection, IEnumerable<ImmutableArray<DiagnosticAnalyzer>> ProjectAnalyzerCollection) GetAnalyzerCollections(
+                    ImmutableDictionary<object, ImmutableArray<DiagnosticAnalyzer>> analyzersPerReference,
+                    ImmutableHashSet<object> referenceIdsToRedirectAsProjectAnalyzers)
+                {
+                    if (referenceIdsToRedirectAsProjectAnalyzers.IsEmpty)
+                    {
+                        return (analyzersPerReference.Values, []);
+                    }
+
+                    var hostAnalyzerCollection = ArrayBuilder<ImmutableArray<DiagnosticAnalyzer>>.GetInstance();
+                    var projectAnalyzerCollection = ArrayBuilder<ImmutableArray<DiagnosticAnalyzer>>.GetInstance();
+
+                    foreach (var (referenceId, analyzers) in analyzersPerReference)
+                    {
+                        if (referenceIdsToRedirectAsProjectAnalyzers.Contains(referenceId))
+                        {
+                            projectAnalyzerCollection.Add(analyzers);
+                        }
+                        else
+                        {
+                            hostAnalyzerCollection.Add(analyzers);
+                        }
+                    }
+
+                    return (hostAnalyzerCollection.ToImmutableAndFree(), projectAnalyzerCollection.ToImmutableAndFree());
+                }
+            }
+
+            private static ImmutableHashSet<object> GetReferenceIdsToRedirectAsProjectAnalyzers(Project project)
+            {
+                if (project.State.HasSdkCodeStyleAnalyzers)
+                {
+                    // When a project uses CodeStyle analyzers added by the SDK, we remove them in favor of the
+                    // Features analyzers. We need to then treat the Features analyzers as Project analyzers so
+                    // they do not get access to the Host fallback options.
+                    return GetFeaturesAnalyzerReferenceIds(project.Solution.SolutionState.Analyzers);
+                }
+
+                return [];
+
+                static ImmutableHashSet<object> GetFeaturesAnalyzerReferenceIds(HostDiagnosticAnalyzers hostAnalyzers)
+                {
+                    var builder = ImmutableHashSet.CreateBuilder<object>();
+
+                    foreach (var analyzerReference in hostAnalyzers.HostAnalyzerReferences)
+                    {
+                        if (analyzerReference.IsFeaturesAnalyzer())
+                            builder.Add(analyzerReference.Id);
+                    }
+
+                    return builder.ToImmutable();
+                }
             }
 
             private sealed class HostAnalyzerStateSets

src/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.StateManager.cs

@@ -187,23 +187,28 @@ private static ImmutableDictionary<DiagnosticAnalyzer, StateSet> CreateStateSetM
 
             private readonly struct HostAnalyzerStateSetKey : IEquatable<HostAnalyzerStateSetKey>
             {
-                public HostAnalyzerStateSetKey(string language, IReadOnlyList<AnalyzerReference> analyzerReferences)
+                public HostAnalyzerStateSetKey(string language, bool hasSdkCodeStyleAnalyzers, IReadOnlyList<AnalyzerReference> analyzerReferences)
                 {
                     Language = language;
+                    HasSdkCodeStyleAnalyzers = hasSdkCodeStyleAnalyzers;
                     AnalyzerReferences = analyzerReferences;
                 }
 
                 public string Language { get; }
+                public bool HasSdkCodeStyleAnalyzers { get; }
                 public IReadOnlyList<AnalyzerReference> AnalyzerReferences { get; }
 
                 public bool Equals(HostAnalyzerStateSetKey other)
-                    => Language == other.Language && AnalyzerReferences == other.AnalyzerReferences;
+                    => Language == other.Language &&
+                       HasSdkCodeStyleAnalyzers == other.HasSdkCodeStyleAnalyzers &&
+                       AnalyzerReferences == other.AnalyzerReferences;
 
                 public override bool Equals(object? obj)
                     => obj is HostAnalyzerStateSetKey key && Equals(key);
 
                 public override int GetHashCode()
-                    => Hash.Combine(Language.GetHashCode(), AnalyzerReferences.GetHashCode());
+                    => Hash.Combine(Language.GetHashCode(),
+                       Hash.Combine(HasSdkCodeStyleAnalyzers.GetHashCode(), AnalyzerReferences.GetHashCode()));
             }
         }
     }

src/VisualStudio/CSharp/Test/ProjectSystemShim/CPS/AdditionalPropertiesTests.cs

@@ -4,6 +4,7 @@
 
 #nullable disable
 
+using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CSharp;
@@ -151,5 +152,29 @@ void TestLegacyProject()
                 Assert.Equal(expectedRunAnalyzers, environment.Workspace.CurrentSolution.Projects.Single().State.RunAnalyzers);
             }
         }
+
+        [WpfFact]
+        public async Task SetProperty_CompilerGeneratedFilesOutputPath_CPS()
+        {
+            using (var environment = new TestEnvironment())
+            using (var project = await CSharpHelpers.CreateCSharpCPSProjectAsync(environment, "Test"))
+            {
+                Assert.Null(environment.Workspace.CurrentSolution.Projects.Single().CompilationOutputInfo.GeneratedFilesOutputDirectory);
+
+                // relative path is relative to the project dir:
+                project.SetProperty(BuildPropertyNames.CompilerGeneratedFilesOutputPath, "generated");
+                AssertEx.AreEqual(
+                    Path.Combine(Path.GetDirectoryName(project.ProjectFilePath), "generated"),
+                    environment.Workspace.CurrentSolution.Projects.Single().CompilationOutputInfo.GeneratedFilesOutputDirectory);
+
+                var path = Path.Combine(TempRoot.Root, "generated");
+                project.SetProperty(BuildPropertyNames.CompilerGeneratedFilesOutputPath, path);
+                AssertEx.AreEqual(path, environment.Workspace.CurrentSolution.Projects.Single().CompilationOutputInfo.GeneratedFilesOutputDirectory);
+
+                // empty path:
+                project.SetProperty(BuildPropertyNames.CompilerGeneratedFilesOutputPath, "");
+                Assert.Null(environment.Workspace.CurrentSolution.Projects.Single().CompilationOutputInfo.GeneratedFilesOutputDirectory);
+            }
+        }
     }
 }

src/VisualStudio/CSharp/Test/ProjectSystemShim/CPS/CSharpCompilerOptionsTests.cs

@@ -185,8 +185,27 @@ public async Task ChecksumAlgorithm_CPS()
 
             cpsProject.SetOptions(ImmutableArray.Create("/checksumalgorithm:SHA1"));
 
-            var project = environment.Workspace.CurrentSolution.Projects.Single();
             Assert.Equal(SourceHashAlgorithm.Sha1, environment.Workspace.CurrentSolution.Projects.Single().State.ChecksumAlgorithm);
         }
+
+        [WpfFact]
+        public async Task CompilerGeneratedFilesOutputPath_CPS()
+        {
+            using var environment = new TestEnvironment();
+            using var cpsProject = await CSharpHelpers.CreateCSharpCPSProjectAsync(environment, "Test");
+
+            Assert.Null(environment.Workspace.CurrentSolution.Projects.Single().CompilationOutputInfo.GeneratedFilesOutputDirectory);
+
+            var path = Path.Combine(TempRoot.Root, "generated");
+            cpsProject.SetOptions(["/generatedfilesout:" + path]);
+
+            AssertEx.AreEqual(path, environment.Workspace.CurrentSolution.Projects.Single().CompilationOutputInfo.GeneratedFilesOutputDirectory);
+
+            // relative path is relative to the project dir:
+            cpsProject.SetOptions(["/generatedfilesout:gen2"]);
+            AssertEx.AreEqual(
+                Path.Combine(Path.GetDirectoryName(cpsProject.ProjectFilePath), "gen2"),
+                environment.Workspace.CurrentSolution.Projects.Single().CompilationOutputInfo.GeneratedFilesOutputDirectory);
+        }
     }
 }

src/VisualStudio/Core/Impl/ProjectSystem/CPS/CPSProject_IWorkspaceProjectContext.cs

@@ -173,33 +173,30 @@ public void SetProperty(string name, string? value)
             }
             else if (name == BuildPropertyNames.TargetRefPath)
             {
-                // If we don't have a path, always set it to null
+                _projectSystemProject.OutputRefFilePath = GetAbsolutePath(value);
+            }
+            else if (name == BuildPropertyNames.CompilerGeneratedFilesOutputPath)
+            {
+                _projectSystemProject.GeneratedFilesOutputDirectory = GetAbsolutePath(value);
+            }
+
+            string? GetAbsolutePath(string? value)
+            {
                 if (string.IsNullOrEmpty(value))
                 {
-                    _projectSystemProject.OutputRefFilePath = null;
+                    return null;
                 }
-                else
+
+                if (PathUtilities.IsAbsolute(value))
                 {
-                    // If we only have a non-rooted path, make it full. This is apparently working around cases
-                    // where CPS pushes us a temporary path when they're loading. It's possible this hack
-                    // can be removed now, but we still have tests asserting it.
-                    if (!PathUtilities.IsAbsolute(value))
-                    {
-                        var rootDirectory = _projectSystemProject.FilePath != null
-                                            ? Path.GetDirectoryName(_projectSystemProject.FilePath)
-                                            : Path.GetTempPath();
-
-                        _projectSystemProject.OutputRefFilePath = Path.Combine(rootDirectory, value);
-                    }
-                    else
-                    {
-                        _projectSystemProject.OutputRefFilePath = value;
-                    }
+                    return value;
                 }
-            }
-            else if (name == BuildPropertyNames.CompilerGeneratedFilesOutputPath)
-            {
-                _projectSystemProject.GeneratedFilesOutputDirectory = string.IsNullOrWhiteSpace(value) ? null : value;
+
+                var rootDirectory = _projectSystemProject.FilePath != null
+                    ? Path.GetDirectoryName(_projectSystemProject.FilePath)
+                    : Path.GetTempPath();
+
+                return Path.Combine(rootDirectory, value);
             }
         }