Fix S6966 FPs/FNs: FPs/FNs after peach validation

analyzers/src/SonarAnalyzer.CSharp/Rules/UseAwaitableMethod.cs

@@ -101,8 +101,9 @@ private static ImmutableArray<ISymbol> FindAwaitableAlternatives(WellKnownExtens
                 : containingSymbol.ContainingType; // If not dotted, than the scope is the current type. Local function support is missing here.
             var members = GetMethodSymbolsInScope($"{methodSymbol.Name}Async", wellKnownExtensionMethodContainer, invokedType, methodSymbol.ContainingType);
             var awaitableCandidates = members.Where(x => x.IsAwaitableNonDynamic());
-            var awaitableAlternatives = SpeculativeBindCandidates(semanticModel, codeBlock, awaitableRoot, invocationExpression, awaitableCandidates).ToImmutableArray();
-            return awaitableAlternatives;
+            var awaitableAlternatives = SpeculativeBindCandidates(semanticModel, codeBlock, awaitableRoot, invocationExpression, awaitableCandidates);
+            var withoutContainer = awaitableAlternatives.Where(x => !containingSymbol.Equals(x)).ToImmutableArray(); // Exclude candidates that would resolve to the containing method (endless loop)
+            return withoutContainer;
         }
         return ImmutableArray<ISymbol>.Empty;
     }
@@ -158,7 +159,8 @@ private static IMethodSymbol SpeculativeBindCandidate(SemanticModel semanticMode
             }
             if (original == awaitableRoot && result is ExpressionSyntax resultExpression)
             {
-                result = SyntaxFactory.AwaitExpression(resultExpression);
+                result = SyntaxFactory.ParenthesizedExpression(
+                    SyntaxFactory.AwaitExpression(resultExpression.WithoutTrivia().WithLeadingTrivia(SyntaxFactory.ElasticSpace))).WithTriviaFrom(resultExpression);
             }
             return result;
         });

analyzers/tests/SonarAnalyzer.Test/Rules/UseAwaitableMethodTest.cs

@@ -93,5 +93,13 @@ public void UseAwaitableMethod_EF() =>
         .AddReferences(NuGetMetadataReference.MicrosoftEntityFrameworkCoreSqlServer(EntityFrameworkVersion))
         .AddPaths("UseAwaitableMethod_EF.cs")
         .Verify();
+
+    [TestMethod]
+    public void UseAwaitableMethod_MongoDb() =>
+        builder
+        .WithOptions(ParseOptionsHelper.FromCSharp11)
+        .AddReferences(NuGetMetadataReference.MongoDBDriver())
+        .AddPaths("UseAwaitableMethod_MongoDBDriver.cs")
+        .Verify();
 #endif
 }

analyzers/tests/SonarAnalyzer.Test/TestCases/UseAwaitableMethod.cs

@@ -244,3 +244,20 @@ async Task Test()
         VoidMethod(1); // FN. CancellationToken.None could be provided by the code fix
     }
 }
+
+class ResolvesToSelf
+{
+    public void Synchronous() { }
+
+    public async Task SynchronousAsync()
+    {
+        Synchronous(); // Compliant. The fix would cause an endless loop
+    }
+
+    public void Generic<T>() { }
+
+    public async Task GenericAsync<T>()
+    {
+        Generic<T>(); // Compliant. The fix would cause an endless loop
+    }
+}

analyzers/tests/SonarAnalyzer.Test/TestCases/UseAwaitableMethod_MongoDBDriver.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using MongoDB.Driver;
+
+public record Person(int Id, string Name);
+
+public class MongoDBDriver
+{
+    public async Task Query(IMongoCollection<Person> personCollection)
+    {
+        var sort = Builders<Person>.Sort.Descending(nameof(Person.Name));
+        // FP for
+        // * Find https://mongodb.github.io/mongo-csharp-driver/2.8/apidocs/html/M_MongoDB_Driver_IMongoCollectionExtensions_Find__1_3.htm
+        // * FindAsync https://mongodb.github.io/mongo-csharp-driver/2.8/apidocs/html/M_MongoDB_Driver_IMongoCollectionExtensions_FindAsync__1_3.htm
+        // Speculative binding finds "FindAsync" but the return type IAsyncCursor<> of FindAsync is not compatible with return type IFindFluent<,> of "Find"
+        // Speculative binding does overload resolution according to the C# rules, which ignore return types.
+        // It seems to ignore the compiler binding error for the following "Sort" which is only defined on IFindFluent, but not in IAsyncCursor.
+        var snapshot = await personCollection.Find(s => s.Id > 10) // Noncompliant FP
+            .Sort(sort) // Not defined on IAsyncCursor (return type of FindAsync)
+            .FirstOrDefaultAsync().ConfigureAwait(false);
+    }
+}

analyzers/tests/SonarAnalyzer.TestFramework/MetadataReferences/NuGetMetadataReference.cs

@@ -119,6 +119,10 @@ public static References MicrosoftNetSdkFunctions(string packageVersion = Consta
     public static References MicrosoftNetWebApiCore(string packageVersion) => Create("Microsoft.AspNet.WebApi.Core", packageVersion);
     public static References MicrosoftSqlServerCompact(string packageVersion = "4.0.8876.1") => Create("Microsoft.SqlServer.Compact", packageVersion);
     public static References MicrosoftWebXdt(string packageVersion = "3.0.0") => Create("Microsoft.Web.Xdt", packageVersion);
+    public static References MongoDBDriver(string packageVersion = Constants.NuGetLatestVersion) =>
+        Create("MongoDB.Driver", packageVersion)
+        .Concat(MongoDBDriverCore(packageVersion));
+    public static References MongoDBDriverCore(string packageVersion = Constants.NuGetLatestVersion) => Create("MongoDB.Driver.Core", packageVersion);
     public static References MonoPosixNetStandard(string packageVersion = "1.0.0") => Create("Mono.Posix.NETStandard", packageVersion, "linux-x64");
     public static References MonoDataSqlite(string packageVersion = Constants.NuGetLatestVersion) => Create("Mono.Data.Sqlite", packageVersion);
     public static References Moq(string packageVersion) => Create("Moq", packageVersion);