Update SA1100 for covariant return types

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp9/ReadabilityRules/SA1100CSharp9UnitTests.cs

@@ -3,9 +3,110 @@
 
 namespace StyleCop.Analyzers.Test.CSharp9.ReadabilityRules
 {
+    using System.Threading;
+    using System.Threading.Tasks;
+    using Microsoft.CodeAnalysis.Testing;
     using StyleCop.Analyzers.Test.CSharp8.ReadabilityRules;
+    using StyleCop.Analyzers.Test.Helpers;
+    using Xunit;
+    using static StyleCop.Analyzers.Test.Verifiers.StyleCopCodeFixVerifier<
+        StyleCop.Analyzers.ReadabilityRules.SA1100DoNotPrefixCallsWithBaseUnlessLocalImplementationExists,
+        StyleCop.Analyzers.ReadabilityRules.SA1100CodeFixProvider>;
 
     public partial class SA1100CSharp9UnitTests : SA1100CSharp8UnitTests
     {
+        [Fact]
+        [WorkItem(3975, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3975")]
+        public async Task TestCovariantOverrideAllowsBaseCallWhenOverrideExistsAsync()
+        {
+            var testCode = @"
+public class BaseType
+{
+}
+
+public class DerivedType : BaseType
+{
+}
+
+public class BaseClass
+{
+    protected virtual BaseType Create() => new BaseType();
+}
+
+public class DerivedClass : BaseClass
+{
+    protected override DerivedType Create()
+    {
+        var value = base.Create();
+        return new DerivedType();
+    }
+}
+";
+
+            await VerifyCSharpDiagnosticAsync(testCode, DiagnosticResult.EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        [WorkItem(3975, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3975")]
+        public async Task TestBaseCallFlaggedWhenOverrideOnlyInIntermediateTypeAsync()
+        {
+            var testCode = @"
+public class BaseType
+{
+}
+
+public class DerivedType : BaseType
+{
+}
+
+public class BaseClass
+{
+    protected virtual BaseType Create() => new BaseType();
+}
+
+public class IntermediateClass : BaseClass
+{
+    protected override DerivedType Create() => new DerivedType();
+}
+
+public class DerivedClass : IntermediateClass
+{
+    public BaseType CreateThroughBase()
+    {
+        return [|base|].Create();
+    }
+}
+";
+
+            var fixedCode = @"
+public class BaseType
+{
+}
+
+public class DerivedType : BaseType
+{
+}
+
+public class BaseClass
+{
+    protected virtual BaseType Create() => new BaseType();
+}
+
+public class IntermediateClass : BaseClass
+{
+    protected override DerivedType Create() => new DerivedType();
+}
+
+public class DerivedClass : IntermediateClass
+{
+    public BaseType CreateThroughBase()
+    {
+        return this.Create();
+    }
+}
+";
+
+            await VerifyCSharpFixAsync(testCode, DiagnosticResult.EmptyDiagnosticResults, fixedCode, CancellationToken.None).ConfigureAwait(false);
+        }
     }
 }

documentation/SA1100.md

@@ -44,10 +44,14 @@ public override string JoinName(string first, string last)
 }
 ```
 
-At this point, the local call to `base.JoinName(...)` most likely introduces a bug into the code. This call will always call the base class method and will cause the local override to be ignored. 
+At this point, the local call to `base.JoinName(...)` most likely introduces a bug into the code. This call will always call the base class method and will cause the local override to be ignored.
 
 For this reason, calls to members from a base class should not begin with `base.`, unless a local override is implemented, and the developer wants to specifically call the base class member. When there is no local override of the base class member, the call should be prefixed with `this.` rather than `base.`.
 
+### Covariant return types
+
+Starting in C# 9, overrides can return a more derived type than the base member. A `base.` call still bypasses the most-derived override, even when an intermediate class provides a covariant implementation. SA1100 continues to report `base.` calls from a class that does not declare its own override, and the suggested fix remains to call the member through `this.` instead.
+
 ## How to fix violations
 
 To fix a violation of this rule, change the `base.` prefix to `this.`.