Fix S3253/S6605/SA1625/S103 warnings

eng/Analyzers.targets

@@ -4,6 +4,7 @@
     <PackageReference Include="SonarAnalyzer.CSharp" PrivateAssets="All" />
     <PackageReference Include="StyleCop.Analyzers" PrivateAssets="All" IncludeAssets="runtime; build; native; contentfiles; analyzers; buildtransitive" />
     <AdditionalFiles Include="$(MSBuildThisFileDirectory)analyzers\BannedSymbols.txt" Condition=" '$(IsTestProject)' != 'true' " Visible="false" />
+    <AdditionalFiles Include="$(MSBuildThisFileDirectory)analyzers\SonarLint.xml" Visible="False" />
     <AdditionalFiles Include="$(MsBuildThisFileDirectory)analyzers\Stylecop.json" Visible="false" />
     <EditorConfigFiles Include="$(MsBuildThisFileDirectory)analyzers\Stylecop.globalconfig" />
     <EditorConfigFiles Include="$(MsBuildThisFileDirectory)analyzers\$(ProjectType).globalconfig" />

eng/analyzers/SonarLint.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<AnalysisInput>
+  <Rules>
+    <Rule>
+      <Key>S103</Key>
+      <Parameters>
+        <Parameter>
+          <Key>maximumLineLength</Key>
+          <Value>500</Value>
+        </Parameter>
+      </Parameters>
+    </Rule>
+  </Rules>
+</AnalysisInput>

src/Polly/Bulkhead/AsyncBulkheadSyntax.cs

@@ -24,7 +24,6 @@ public static AsyncBulkheadPolicy BulkheadAsync(int maxParallelization)
     /// <returns>The policy instance.</returns>
     /// <exception cref="ArgumentOutOfRangeException">maxParallelization;Value must be greater than zero.</exception>
     /// <exception cref="ArgumentNullException">Thrown when <paramref name="onBulkheadRejectedAsync"/> is <see langword="null"/>.</exception>
-    /// <returns>The policy instance.</returns>
     public static AsyncBulkheadPolicy BulkheadAsync(int maxParallelization, Func<Context, Task> onBulkheadRejectedAsync) =>
         BulkheadAsync(maxParallelization, 0, onBulkheadRejectedAsync);
 

src/Polly/Bulkhead/BulkheadSyntax.cs

@@ -52,7 +52,7 @@ public static BulkheadPolicy Bulkhead(int maxParallelization, int maxQueuingActi
     /// <param name="onBulkheadRejected">An action to call, if the bulkhead rejects execution due to oversubscription.</param>
     /// <returns>The policy instance.</returns>
     /// <exception cref="ArgumentOutOfRangeException">maxParallelization;Value must be greater than zero.</exception>
-    /// <exception cref="ArgumentOutOfRangeException">maxParallelization;Value must be greater than zero.</exception>
+    /// <exception cref="ArgumentOutOfRangeException">maxParallelization;Value must be greater than or equal to zero.</exception>
     /// <exception cref="ArgumentNullException">Thrown when <paramref name="onBulkheadRejected"/> is <see langword="null"/>.</exception>
     public static BulkheadPolicy Bulkhead(int maxParallelization, int maxQueuingActions, Action<Context> onBulkheadRejected)
     {

src/Polly/Fallback/AsyncFallbackPolicy.cs

@@ -45,7 +45,10 @@ protected override Task ImplementationAsync(
     /// <inheritdoc/>
     protected override Task<TResult> ImplementationAsync<TResult>(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken,
         bool continueOnCapturedContext) =>
-        throw new InvalidOperationException($"You have executed the generic .Execute<{nameof(TResult)}> method on a non-generic {nameof(FallbackPolicy)}.  A non-generic {nameof(FallbackPolicy)} only defines a fallback action which returns void; it can never return a substitute {nameof(TResult)} value.  To use {nameof(FallbackPolicy)} to provide fallback {nameof(TResult)} values you must define a generic fallback policy {nameof(FallbackPolicy)}<{nameof(TResult)}>.  For example, define the policy as Policy<{nameof(TResult)}>.Handle<Whatever>.Fallback<{nameof(TResult)}>(/* some {nameof(TResult)} value or Func<..., {nameof(TResult)}> */);");
+        throw new InvalidOperationException($"You have executed the generic .Execute<{nameof(TResult)}> method on a non-generic {nameof(FallbackPolicy)}.  " +
+            $"A non-generic {nameof(FallbackPolicy)} only defines a fallback action which returns void; it can never return a substitute {nameof(TResult)} value.  " +
+            $"To use {nameof(FallbackPolicy)} to provide fallback {nameof(TResult)} values you must define a generic fallback policy {nameof(FallbackPolicy)}<{nameof(TResult)}>.  " +
+            $"For example, define the policy as Policy<{nameof(TResult)}>.Handle<Whatever>.Fallback<{nameof(TResult)}>(/* some {nameof(TResult)} value or Func<..., {nameof(TResult)}> */);");
 }
 
 /// <summary>

src/Polly/Fallback/FallbackPolicy.cs

@@ -42,7 +42,10 @@ protected override void Implementation(Action<Context, CancellationToken> action
 
     /// <inheritdoc/>
     protected override TResult Implementation<TResult>(Func<Context, CancellationToken, TResult> action, Context context, CancellationToken cancellationToken) =>
-        throw new InvalidOperationException($"You have executed the generic .Execute<{nameof(TResult)}> method on a non-generic {nameof(FallbackPolicy)}.  A non-generic {nameof(FallbackPolicy)} only defines a fallback action which returns void; it can never return a substitute {nameof(TResult)} value.  To use {nameof(FallbackPolicy)} to provide fallback {nameof(TResult)} values you must define a generic fallback policy {nameof(FallbackPolicy)}<{nameof(TResult)}>.  For example, define the policy as Policy<{nameof(TResult)}>.Handle<Whatever>.Fallback<{nameof(TResult)}>(/* some {nameof(TResult)} value or Func<..., {nameof(TResult)}> */);");
+        throw new InvalidOperationException($"You have executed the generic .Execute<{nameof(TResult)}> method on a non-generic {nameof(FallbackPolicy)}.  " +
+            $"A non-generic {nameof(FallbackPolicy)} only defines a fallback action which returns void; it can never return a substitute {nameof(TResult)} value.  " +
+            $"To use {nameof(FallbackPolicy)} to provide fallback {nameof(TResult)} values you must define a generic fallback policy {nameof(FallbackPolicy)}<{nameof(TResult)}>.  " +
+            $"For example, define the policy as Policy<{nameof(TResult)}>.Handle<Whatever>.Fallback<{nameof(TResult)}>(/* some {nameof(TResult)} value or Func<..., {nameof(TResult)}> */);");
 }
 
 /// <summary>

src/Polly/Polly.csproj

@@ -7,14 +7,14 @@
     <ProjectType>Library</ProjectType>
     <MutationScore>70</MutationScore>
     <IncludePollyUsings>true</IncludePollyUsings>
-    <NoWarn>$(NoWarn);IDE0011;S103;S3872;SA1402;SA1414;S3215</NoWarn>
+    <NoWarn>$(NoWarn);IDE0011;S3872;SA1402;SA1414;S3215</NoWarn>
     <NoWarn>$(NoWarn);IDE1006;CA1062;S107;CA1068;S4039;CA1000;CA1063;CA1031;CA1051</NoWarn>
     <NoWarn>$(NoWarn);CA2211;S2223;CA1032;CA1815;CA1816;S4457;SA1615;CA1033</NoWarn>
-    <NoWarn>$(NoWarn);S4023;CA1010;S3442;CA1064;SA1649;SA1625;SA1623;SA1118</NoWarn>
-    <NoWarn>$(NoWarn);S3253;S3971;S6605;CA1724;CA1716;SA1108;CA1710;S4049;S3246</NoWarn>
+    <NoWarn>$(NoWarn);S4023;CA1010;S3442;CA1064;SA1649;SA1623;SA1118</NoWarn>
+    <NoWarn>$(NoWarn);S3971;CA1724;CA1716;SA1108;CA1710;S4049;S3246</NoWarn>
     <NoWarn>$(NoWarn);CA1805</NoWarn>
 
-    <!--Pulic API Analyzers: We do not need to fix these as it would break compatibility with released Polly versions-->
+    <!--Public API Analyzers: We do not need to fix these as it would break compatibility with released Polly versions-->
     <NoWarn>$(NoWarn);RS0037;</NoWarn>
   </PropertyGroup>
 

src/Polly/ResultPredicates.cs

@@ -24,7 +24,7 @@ public bool AnyMatch(TResult result)
         if (_predicates == null)
             return false;
 
-        return _predicates.Any(predicate => predicate(result));
+        return _predicates.Exists(predicate => predicate(result));
     }
 
     /// <summary>

src/Polly/Timeout/AsyncTimeoutSyntax.cs

@@ -78,7 +78,7 @@ public static AsyncTimeoutPolicy TimeoutAsync(int seconds, Func<Context, TimeSpa
     /// <remarks>The Task parameter will be null if the executed action responded cooperatively to cancellation before the policy timed it out.</remarks></param>
     /// <returns>The policy instance.</returns>
     /// <exception cref="ArgumentOutOfRangeException">seconds;Value must be greater than zero.</exception>
-    /// <exception cref="ArgumentNullException">seconds;Value must be greater than zero.</exception>
+    /// <exception cref="ArgumentNullException">seconds;Value must not be null.</exception>
     public static AsyncTimeoutPolicy TimeoutAsync(int seconds, TimeoutStrategy timeoutStrategy, Func<Context, TimeSpan, Task, Task> onTimeoutAsync)
     {
         TimeoutValidator.ValidateSecondsTimeout(seconds);
@@ -95,7 +95,7 @@ public static AsyncTimeoutPolicy TimeoutAsync(int seconds, TimeoutStrategy timeo
     /// <remarks>The Task parameter will be null if the executed action responded cooperatively to cancellation before the policy timed it out.</remarks></param>
     /// <returns>The policy instance.</returns>
     /// <exception cref="ArgumentOutOfRangeException">seconds;Value must be greater than zero.</exception>
-    /// <exception cref="ArgumentNullException">seconds;Value must be greater than zero.</exception>
+    /// <exception cref="ArgumentNullException">seconds;Value must not be null.</exception>
     public static AsyncTimeoutPolicy TimeoutAsync(int seconds, TimeoutStrategy timeoutStrategy, Func<Context, TimeSpan, Task, Exception, Task> onTimeoutAsync)
     {
         if (seconds <= 0)

src/Polly/Timeout/TimeoutEngine.cs

@@ -38,7 +38,13 @@ internal static TResult Implementation<TResult>(
                 combinedToken);           // cancellation token here only allows Task.Run() to not begin the passed delegate at all, if cancellation occurs prior to invoking the delegate.
             try
             {
-                actionTask.Wait(timeoutCancellationTokenSource.Token); // cancellation token here cancels the Wait() and causes it to throw, but does not cancel actionTask.  We use only timeoutCancellationTokenSource.Token here, not combinedToken.  If we allowed the user's cancellation token to cancel the Wait(), in this pessimistic scenario where the user delegate may not observe that cancellation, that would create a no-longer-observed task.  That task could in turn later fault before completing, risking an UnobservedTaskException.
+                /*
+                 * Cancellation token here cancels the Wait() and causes it to throw, but does not cancel actionTask.
+                 * We use only timeoutCancellationTokenSource.Token here, not combinedToken.
+                 * If we allowed the user's cancellation token to cancel the Wait(), in this pessimistic scenario where the user delegate may not observe that cancellation, that would create a no-longer-observed task.
+                 * That task could in turn later fault before completing, risking an UnobservedTaskException.
+                 */
+                actionTask.Wait(timeoutCancellationTokenSource.Token);
             }
             catch (AggregateException ex) when (ex.InnerExceptions.Count == 1) // Issue #270.  Unwrap extra AggregateException caused by the way pessimistic timeout policy for synchronous executions is necessarily constructed.
             {