Clean up

src/CodeFixes/CodeFixContextExtensions.cs

@@ -1,9 +1,5 @@
-using System.Composition;
-using System.Diagnostics.CodeAnalysis;
-using Microsoft.CodeAnalysis.CodeActions;
+using System.Diagnostics.CodeAnalysis;
 using Microsoft.CodeAnalysis.CodeFixes;
-using Microsoft.CodeAnalysis.Editing;
-using Microsoft.CodeAnalysis.Simplification;
 
 namespace Moq.CodeFixes;
 

src/CodeFixes/SetExplicitMockBehaviorFixer.cs

@@ -1,5 +1,4 @@
 using System.Composition;
-using System.Diagnostics.CodeAnalysis;
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.Editing;
@@ -8,7 +7,7 @@
 namespace Moq.CodeFixes;
 
 /// <summary>
-/// Fixes for SetExplicitMockBehaviorAnalyzer (Moq1400).
+/// Fixes for <see cref="DiagnosticIds.SetExplicitMockBehavior"/>.
 /// </summary>
 [ExportCodeFixProvider(LanguageNames.CSharp, Name = nameof(SetExplicitMockBehaviorFixer))]
 [Shared]
@@ -71,12 +70,16 @@ public SetExplicitMockBehaviorCodeAction(string title, Document document, Syntax
         protected override async Task<Document> GetChangedDocumentAsync(CancellationToken cancellationToken)
         {
             DocumentEditor editor = await DocumentEditor.CreateAsync(_document, cancellationToken).ConfigureAwait(false);
+            SemanticModel? model = await _document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+            IOperation? operation = model?.GetOperation(_nodeToFix, cancellationToken);
+
             MoqKnownSymbols knownSymbols = new(editor.SemanticModel.Compilation);
 
             if (knownSymbols.MockBehavior is null
                 || knownSymbols.MockBehaviorDefault is null
                 || knownSymbols.MockBehaviorLoose is null
-                || knownSymbols.MockBehaviorStrict is null)
+                || knownSymbols.MockBehaviorStrict is null
+                || operation is null)
             {
                 return _document;
             }
@@ -92,8 +95,8 @@ protected override async Task<Document> GetChangedDocumentAsync(CancellationToke
 
             SyntaxNode newNode = _editType switch
             {
-                DiagnosticEditProperties.EditType.Insert => editor.Generator.InsertArguments(_nodeToFix, _position, argument),
-                DiagnosticEditProperties.EditType.Replace => editor.Generator.ReplaceArgument(_nodeToFix, _position, argument),
+                DiagnosticEditProperties.EditType.Insert => editor.Generator.InsertArguments(operation, _position, argument),
+                DiagnosticEditProperties.EditType.Replace => editor.Generator.ReplaceArgument(operation, _position, argument),
                 _ => throw new InvalidOperationException(),
             };
 

src/CodeFixes/SyntaxGeneratorExtensions.cs

@@ -9,6 +9,12 @@ public static SyntaxNode MemberAccessExpression(this SyntaxGenerator generator,
         return generator.MemberAccessExpression(generator.TypeExpression(fieldSymbol.Type), generator.IdentifierName(fieldSymbol.Name));
     }
 
+    public static SyntaxNode InsertArguments(this SyntaxGenerator generator, IOperation operation, int index, params SyntaxNode[] items)
+    {
+        // Ideally we could modify argument lists only using the IOperation APIs, but I haven't figured out a way to do that yet.
+        return generator.InsertArguments(operation.Syntax, index, items);
+    }
+
     public static SyntaxNode InsertArguments(this SyntaxGenerator generator, SyntaxNode syntax, int index, params SyntaxNode[] items)
     {
         if (Array.Exists(items, item => item is not ArgumentSyntax))
@@ -19,29 +25,26 @@ public static SyntaxNode InsertArguments(this SyntaxGenerator generator, SyntaxN
         if (syntax is InvocationExpressionSyntax invocation)
         {
             SeparatedSyntaxList<ArgumentSyntax> arguments = invocation.ArgumentList.Arguments;
-
             arguments = arguments.InsertRange(index, items.OfType<ArgumentSyntax>());
-
-            syntax = syntax.ReplaceNode(invocation.ArgumentList, invocation.ArgumentList.WithArguments(arguments));
-
-            return syntax;
+            return invocation.WithArgumentList(SyntaxFactory.ArgumentList(arguments));
         }
 
         if (syntax is ObjectCreationExpressionSyntax creation)
         {
             SeparatedSyntaxList<ArgumentSyntax> arguments = creation.ArgumentList?.Arguments ?? [];
-
             arguments = arguments.InsertRange(index, items.OfType<ArgumentSyntax>());
-            ArgumentListSyntax argumentList = SyntaxFactory.ArgumentList(arguments);
-
-            syntax = syntax.ReplaceNode(creation, creation.WithArgumentList(argumentList));
-
-            return syntax;
+            return creation.WithArgumentList(SyntaxFactory.ArgumentList(arguments));
         }
 
         throw new ArgumentException($"Must be of type {nameof(InvocationExpressionSyntax)} or {nameof(ObjectCreationExpressionSyntax)} but is of type {syntax.GetType().Name}", nameof(syntax));
     }
 
+    public static SyntaxNode ReplaceArgument(this SyntaxGenerator generator, IOperation operation, int index, SyntaxNode item)
+    {
+        // Ideally we could modify argument lists only using the IOperation APIs, but I haven't figured out a way to do that yet.
+        return generator.ReplaceArgument(operation.Syntax, index, item);
+    }
+
     public static SyntaxNode ReplaceArgument(this SyntaxGenerator generator, SyntaxNode syntax, int index, SyntaxNode item)
     {
         if (item is not ArgumentSyntax argument)
@@ -52,24 +55,15 @@ public static SyntaxNode ReplaceArgument(this SyntaxGenerator generator, SyntaxN
         if (syntax is InvocationExpressionSyntax invocation)
         {
             SeparatedSyntaxList<ArgumentSyntax> arguments = invocation.ArgumentList.Arguments;
-
             arguments = arguments.RemoveAt(index).Insert(index, argument);
-
-            syntax = syntax.ReplaceNode(invocation.ArgumentList, invocation.ArgumentList.WithArguments(arguments));
-
-            return syntax;
+            return invocation.WithArgumentList(SyntaxFactory.ArgumentList(arguments));
         }
 
         if (syntax is ObjectCreationExpressionSyntax creation)
         {
             SeparatedSyntaxList<ArgumentSyntax> arguments = creation.ArgumentList?.Arguments ?? [];
-
             arguments = arguments.RemoveAt(index).Insert(index, argument);
-            ArgumentListSyntax argumentList = SyntaxFactory.ArgumentList(arguments);
-
-            syntax = syntax.ReplaceNode(creation, creation.WithArgumentList(argumentList));
-
-            return syntax;
+            return creation.WithArgumentList(SyntaxFactory.ArgumentList(arguments));
         }
 
         throw new ArgumentException($"Must be of type {nameof(InvocationExpressionSyntax)} or {nameof(ObjectCreationExpressionSyntax)} but is of type {syntax.GetType().Name}", nameof(syntax));