Merge pull request #62947 from CyrusNajmabadi/banAPI2

Ban SyntaxEditor constructor that takes HostWorkspaceServices.

Author: CyrusNajmabadi

eng/config/BannedSymbols.txt

@@ -34,3 +34,4 @@ M:Microsoft.CodeAnalysis.Simplification.Simplifier.ReduceAsync(Microsoft.CodeAna
 M:Microsoft.CodeAnalysis.Simplification.Simplifier.ReduceAsync(Microsoft.CodeAnalysis.Document,Microsoft.CodeAnalysis.SyntaxAnnotation,Microsoft.CodeAnalysis.Options.OptionSet,System.Threading.CancellationToken); Use overload that takes SimplifierOptions
 M:Microsoft.CodeAnalysis.Simplification.Simplifier.ReduceAsync(Microsoft.CodeAnalysis.Document,Microsoft.CodeAnalysis.Text.TextSpan,Microsoft.CodeAnalysis.Options.OptionSet,System.Threading.CancellationToken); Use overload that takes SimplifierOptions
 M:Microsoft.CodeAnalysis.Simplification.Simplifier.ReduceAsync(Microsoft.CodeAnalysis.Document,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Text.TextSpan},Microsoft.CodeAnalysis.Options.OptionSet,System.Threading.CancellationToken); Use overload that takes SimplifierOptions
+M:Microsoft.CodeAnalysis.Editing.SyntaxEditor.#ctor(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.Host.HostWorkspaceServices); Use overload that takes HostSolutionServices instead

src/Analyzers/CSharp/CodeFixes/InlineDeclaration/CSharpInlineDeclarationCodeFixProvider.cs

@@ -80,12 +80,11 @@ await editor.ApplyExpressionLevelSemanticEditsAsync(
 
                     return (t.invocationOrCreation, additionalNodesToTrack.ToImmutable());
                 },
-                (_1, _2, _3) => true,
+                (_, _, _) => true,
                 (semanticModel, currentRoot, t, currentNode)
                     => ReplaceIdentifierWithInlineDeclaration(
-                        options, semanticModel, currentRoot, t.declarator,
-                        t.identifier, currentNode, declarationsToRemove, document.Project.Solution.Workspace.Services,
-                        cancellationToken),
+                        document, options, semanticModel, currentRoot, t.declarator,
+                        t.identifier, currentNode, declarationsToRemove, cancellationToken),
                 cancellationToken).ConfigureAwait(false);
         }
 
@@ -106,17 +105,17 @@ private static (VariableDeclaratorSyntax declarator, IdentifierNameSyntax identi
         }
 
         private static SyntaxNode ReplaceIdentifierWithInlineDeclaration(
+            Document document,
             CSharpCodeFixOptionsProvider options, SemanticModel semanticModel,
             SyntaxNode currentRoot, VariableDeclaratorSyntax declarator,
             IdentifierNameSyntax identifier, SyntaxNode currentNode,
             HashSet<StatementSyntax> declarationsToRemove,
-            HostWorkspaceServices services,
             CancellationToken cancellationToken)
         {
             declarator = currentRoot.GetCurrentNode(declarator);
             identifier = currentRoot.GetCurrentNode(identifier);
 
-            var editor = new SyntaxEditor(currentRoot, services);
+            var editor = document.GetSyntaxEditor(currentRoot);
             var sourceText = currentRoot.GetText();
 
             var declaration = (VariableDeclarationSyntax)declarator.Parent;

src/Analyzers/CSharp/CodeFixes/UseDeconstruction/CSharpUseDeconstructionCodeFixProvider.cs

@@ -55,13 +55,18 @@ protected override Task FixAllAsync(
             return editor.ApplyMethodBodySemanticEditsAsync(
                 document, nodesToProcess,
                 (semanticModel, node) => true,
-                (semanticModel, currentRoot, node) => UpdateRoot(semanticModel, currentRoot, node, document.Project.Solution.Workspace.Services, cancellationToken),
+                (semanticModel, currentRoot, node) => UpdateRoot(document, semanticModel, currentRoot, node, cancellationToken),
                 cancellationToken);
         }
 
-        private SyntaxNode UpdateRoot(SemanticModel semanticModel, SyntaxNode root, SyntaxNode node, HostWorkspaceServices services, CancellationToken cancellationToken)
+        private SyntaxNode UpdateRoot(
+            Document document,
+            SemanticModel semanticModel,
+            SyntaxNode root,
+            SyntaxNode node,
+            CancellationToken cancellationToken)
         {
-            var editor = new SyntaxEditor(root, services);
+            var editor = document.GetSyntaxEditor(root);
 
             // We use the callback form of ReplaceNode because we may have nested code that
             // needs to be updated in fix-all situations.  For example, nested foreach statements.

src/Analyzers/Core/CodeFixes/RemoveUnusedParametersAndValues/AbstractRemoveUnusedValuesCodeFixProvider.cs

@@ -795,12 +795,9 @@ private async Task<SyntaxNode> ReplaceDiscardDeclarationsWithAssignmentsAsync(Sy
         {
             var service = document.GetLanguageService<IReplaceDiscardDeclarationsWithAssignmentsService>();
             if (service == null)
-            {
                 return memberDeclaration;
-            }
 
-            var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
-            return await service.ReplaceAsync(memberDeclaration, semanticModel, document.Project.Solution.Workspace.Services, cancellationToken).ConfigureAwait(false);
+            return await service.ReplaceAsync(document, memberDeclaration, cancellationToken).ConfigureAwait(false);
         }
 
         /// <summary>

src/Features/Core/Portable/ConvertAutoPropertyToFullProperty/AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs

@@ -109,7 +109,8 @@ private async Task<Document> ExpandToFullPropertyAsync(
                         : new SyntaxNode[] { newGetAccessor, newSetAccessor })
                 .WithLeadingTrivia(property.GetLeadingTrivia());
             fullProperty = ConvertPropertyToExpressionBodyIfDesired(info, fullProperty);
-            var editor = new SyntaxEditor(root, services);
+
+            var editor = document.GetSyntaxEditor(root);
             editor.ReplaceNode(property, fullProperty.WithAdditionalAnnotations(Formatter.Annotation));
 
             // add backing field, plus initializer if it exists 

src/Workspaces/Core/Portable/Editing/SyntaxEditor.cs

@@ -26,7 +26,7 @@ public class SyntaxEditor
         /// </summary>
         [Obsolete("Use SyntaxEditor(SyntaxNode, HostWorkspaceServices)")]
         public SyntaxEditor(SyntaxNode root, Workspace workspace)
-            : this(root, (workspace ?? throw new ArgumentNullException(nameof(workspace))).Services)
+            : this(root, (workspace ?? throw new ArgumentNullException(nameof(workspace))).Services.SolutionServices)
         {
         }
 

src/Workspaces/CoreTest/Editing/SyntaxEditorTests.cs

@@ -36,7 +36,7 @@ private void VerifySyntax<TSyntax>(SyntaxNode node, string expectedText) where T
         }
 
         private SyntaxEditor GetEditor(SyntaxNode root)
-            => new SyntaxEditor(root, EmptyWorkspace.Services);
+            => new SyntaxEditor(root, EmptyWorkspace.Services.SolutionServices);
 
         [Fact]
         public void TestReplaceNode()

src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpReplaceDiscardDeclarationsWithAssignmentsService.cs

@@ -18,6 +18,7 @@
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.ReplaceDiscardDeclarationsWithAssignments;
+using Microsoft.CodeAnalysis.Shared.Extensions;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.ReplaceDiscardDeclarationsWithAssignments
@@ -33,9 +34,13 @@ public CSharpReplaceDiscardDeclarationsWithAssignmentsService()
         {
         }
 
-        public Task<SyntaxNode> ReplaceAsync(SyntaxNode memberDeclaration, SemanticModel semanticModel, HostWorkspaceServices services, CancellationToken cancellationToken)
+        public async Task<SyntaxNode> ReplaceAsync(
+            Document document,
+            SyntaxNode memberDeclaration,
+            CancellationToken cancellationToken)
         {
-            var editor = new SyntaxEditor(memberDeclaration, services);
+            var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+            var editor = document.GetSyntaxEditor(memberDeclaration);
             foreach (var child in memberDeclaration.DescendantNodes())
             {
                 switch (child)
@@ -102,7 +107,7 @@ public Task<SyntaxNode> ReplaceAsync(SyntaxNode memberDeclaration, SemanticModel
                 }
             }
 
-            return Task.FromResult(editor.GetChangedRoot());
+            return editor.GetChangedRoot();
         }
 
         private static bool IsDiscardDeclaration(VariableDeclaratorSyntax variable)

src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Extensions/DocumentExtensions.cs

@@ -218,7 +218,9 @@ public static SyntaxEditor GetSyntaxEditor(this Document document, SyntaxNode ro
         {
 #if CODE_STYLE
             // Remove once Solution.Services becomes public: https://github.com/dotnet/roslyn/issues/62914
+#pragma warning disable RS0030 // Do not used banned APIs.  This is the shim method to use until the api becomes public.
             return new SyntaxEditor(root, document.Project.Solution.Workspace.Services);
+#pragma warning restore RS0030 // Do not used banned APIs
 #else
             return new SyntaxEditor(root, document.Project.Solution.Services);
 #endif

src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/ReplaceDiscardDeclarationsWithAssignments/IReplaceDiscardDeclarationsWithAssignmentsService.cs

@@ -29,6 +29,6 @@ internal interface IReplaceDiscardDeclarationsWithAssignmentsService : ILanguage
         /// where the code transformation wants to generate new discard assignment(s), which would be a compiler error.
         /// This method replaces such discard variable declarations with discard assignments.
         /// </summary>
-        Task<SyntaxNode> ReplaceAsync(SyntaxNode memberDeclaration, SemanticModel semanticModel, HostWorkspaceServices services, CancellationToken cancellationToken);
+        Task<SyntaxNode> ReplaceAsync(Document document, SyntaxNode memberDeclaration, CancellationToken cancellationToken);
     }
 }