1: add option to treat record-based hierarchies as closed

via .editorconfig dotnet_diagnostic.CTH001.suppress_on_record_hierarchies = true

could not make unit tests work for this

ClosedTypeHierarchyDiagnosticSuppressor.Tests/TypeHierarchies.cs

@@ -40,6 +40,18 @@ public sealed class Leaf2 : Root<T> { public Leaf2(T value) : base(value) {} }
 ";
     }
 
+    public static class ProtectedCopyConstructorOnly
+    {
+        public const string ImplicitProtectedCopyCtor = @"
+abstract record Root
+{
+    Root() {}
+    public sealed record Leaf1 : Root {}
+    public sealed record Leaf2 : Root {}
+}
+";
+    }
+
     public static class NotClosed
     {
         public const string RootNotAbstract = @"
@@ -60,10 +72,10 @@ public sealed class Leaf2 : Root {}
 }
 ";
 
-        public const string ImplicitProtectedCopyCtor = @"
-abstract record Root
+        public const string ProtectedCtorOtherThanCopyConstructor = @"
+abstract class Root
 {
-    Root() {}
+    protected Root() {}
     public sealed record Leaf1 : Root {}
     public sealed record Leaf2 : Root {}
 }
@@ -77,5 +89,23 @@ public class Leaf1 : Root {}
     public sealed class Leaf2 : Root {}
 }
 ";
+
+        public const string ExplicitPrivateProtectedCopyCtor = @"
+    abstract class Root
+    {
+        private protected Root(Root root) {}
+        public sealed record Leaf1 : Root {}
+        public sealed record Leaf2 : Root {}
+    }
+    ";
+
+        public const string ExplicitProtectedCopyCtor = @"
+    abstract class Root
+    {
+        protected Root(Root root) {}
+        public sealed record Leaf1 : Root {}
+        public sealed record Leaf2 : Root {}
+    }
+    ";
     }
 }

ClosedTypeHierarchyDiagnosticSuppressor.Tests/TypeHierarchyHelperTests.cs

@@ -1,6 +1,7 @@
 using Microsoft.CodeAnalysis;
 using NUnit.Framework;
 using SvSoft.Analyzers.ClosedTypeHerarchyDiagnosticSuppression;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 
@@ -31,32 +32,65 @@ public void When_type_hierarchy_is_closed_Then_returns_leaf_types(string typeCod
     {
         INamedTypeSymbol type = GetRootTypeCandidate(typeCode, "Root");
 
-        var subtypes = TypeHierarchyHelper.InterpretAsClosedTypeHierarchy(type);
+        var subtypes = TypeHierarchyHelper.InterpretAsClosedTypeHierarchy(type, false);
 
         Assert.That(subtypes, Is.Not.Null);
         Assert.That(subtypes!.Select(s => s.Name), Is.EquivalentTo(expectedSubTypes));
     }
 
     [Test]
     [TestCaseSource(nameof(NotClosedSamples))]
-    public void When_type_hierarchy_is_not_closed_Then_returns_null(string typeCode)
+    public void When_type_hierarchy_is_not_closed_Then_returns_null(string typeCode, bool allowProtectedCopyCtors)
     {
         INamedTypeSymbol type = GetRootTypeCandidate(typeCode, "Root");
 
-        var subtypes = TypeHierarchyHelper.InterpretAsClosedTypeHierarchy(type);
+        var subtypes = TypeHierarchyHelper.InterpretAsClosedTypeHierarchy(type, allowRecords: allowProtectedCopyCtors);
 
         Assert.That(subtypes, Is.Null);
     }
 
+    [Test]
+    [TestCaseSource(nameof(ProtectedCopyConstructorOnlySamples))]
+    public void When_type_hierarchy_is_closed_except_for_copy_ctor_And_copy_ctor_is_not_explicitly_allowed_Then_returns_null(string typeCode, string[] _)
+    {
+        INamedTypeSymbol type = GetRootTypeCandidate(typeCode, "Root");
+
+        var subtypes = TypeHierarchyHelper.InterpretAsClosedTypeHierarchy(type, false);
+
+        Assert.That(subtypes, Is.Null);
+    }
+
+    [Test]
+    [TestCaseSource(nameof(ProtectedCopyConstructorOnlySamples))]
+    public void When_type_hierarchy_is_closed_except_for_copy_ctor_And_copy_ctor_is_explicitly_allowed_Then_returns_leaf_types(string typeCode, string[] expectedSubTypes)
+    {
+        INamedTypeSymbol type = GetRootTypeCandidate(typeCode, "Root");
+
+        var subtypes = TypeHierarchyHelper.InterpretAsClosedTypeHierarchy(type, true);
+
+        Assert.That(subtypes, Is.Not.Null);
+        Assert.That(subtypes!.Select(s => s.Name), Is.EquivalentTo(expectedSubTypes));
+    }
+
     public static readonly IEnumerable<TestCaseData> ClosedSamples = new (string SampleName, string TypeCode, string[] ExpectedTypeNames)[]
     {
         ("Simple", TypeHierarchies.Closed.Simple, new[] { "Leaf1", "Leaf2" }),
         ("Nested", TypeHierarchies.Closed.Nested, new[] { "Leaf1", "Leaf2", "Leaf3" }),
         ("Generic", TypeHierarchies.Closed.Generic, new[] { "Leaf1", "Leaf2" })
     }.Select(t => new TestCaseData(t.TypeCode, t.ExpectedTypeNames).SetArgDisplayNames(t.SampleName));
 
+    public static readonly IEnumerable<TestCaseData> ProtectedCopyConstructorOnlySamples = new (string SampleName, string TypeCode, string[] ExpectedTypeNames)[]
+    {
+        ("ImplicitProtectedCopyCtor", TypeHierarchies.ProtectedCopyConstructorOnly.ImplicitProtectedCopyCtor, new[] { "Leaf1", "Leaf2" }),
+    }.Select(t => new TestCaseData(t.TypeCode, t.ExpectedTypeNames).SetArgDisplayNames(t.SampleName));
+
     public static readonly IEnumerable<TestCaseData> NotClosedSamples = typeof(TypeHierarchies.NotClosed)
         .GetFields()
         .Select(f => (SampleName: f.Name, TypeCode: f.GetValue(null)))
-        .Select(t => new TestCaseData(t.TypeCode).SetArgDisplayNames(t.SampleName));
+        .SelectMany(t => new[] { true, false }.Select(allowCopyCtor => (allowCopyCtor, t))
+        .Select(t => new TestCaseData(t.t.TypeCode, t.allowCopyCtor).SetArgDisplayNames(t.t.SampleName, t.allowCopyCtor ? "allow copy ctor" : "disallow copy ctor")));
+
+    public static readonly IEnumerable<string> NotClosedCodeOnlySamples = typeof(TypeHierarchies.NotClosed)
+        .GetFields()
+        .Select(f => (string)f.GetValue(null)!);
 }

ClosedTypeHierarchyDiagnosticSuppressor/OptionsHelper.cs

@@ -0,0 +1,16 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace SvSoft.Analyzers.ClosedTypeHierarchyDiagnosticSuppression;
+static class OptionsHelper
+{
+    public static bool AreRecordHierarchiesAllowed(this SuppressionAnalysisContext context, SyntaxTree syntaxTree)
+    {
+        AnalyzerConfigOptions options = context.Options.AnalyzerConfigOptionsProvider.GetOptions(syntaxTree);
+        bool allowRecords = options.TryGetValue("dotnet_diagnostic.CTH001.suppress_on_record_hierarchies", out string? allowRecordHierarchiesStr) &&
+            bool.TryParse(allowRecordHierarchiesStr, out bool allowRecordHierarchies)
+            && allowRecordHierarchies;
+
+        return allowRecords;
+    }
+}

ClosedTypeHierarchyDiagnosticSuppressor/SwitchExpressionSuppressor.cs

@@ -1,6 +1,7 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
+using SvSoft.Analyzers.ClosedTypeHierarchyDiagnosticSuppression;
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
@@ -41,6 +42,8 @@ void HandleDiagnostic(Diagnostic diagnostic)
                 return;
             }
 
+            bool allowRecords = context.AreRecordHierarchiesAllowed(node.SyntaxTree);
+
             var switchExpression = node.DescendantNodesAndSelf().OfType<SwitchExpressionSyntax>().FirstOrDefault();
 
             ExpressionSyntax switchee = switchExpression.GoverningExpression;
@@ -51,7 +54,7 @@ void HandleDiagnostic(Diagnostic diagnostic)
                 return;
             }
 
-            if (TypeHierarchyHelper.InterpretAsClosedTypeHierarchy(switcheeType) is not IEnumerable<INamedTypeSymbol> subtypes)
+            if (TypeHierarchyHelper.InterpretAsClosedTypeHierarchy(switcheeType, allowRecords) is not IEnumerable<INamedTypeSymbol> subtypes)
             {
                 return;
             }

ClosedTypeHierarchyDiagnosticSuppressor/SwitchStatementSuppressor.cs

@@ -1,6 +1,7 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
+using SvSoft.Analyzers.ClosedTypeHierarchyDiagnosticSuppression;
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
@@ -18,7 +19,7 @@ public sealed class SwitchStatementSuppressor : DiagnosticSuppressor
         id => new SuppressionDescriptor("CTH001", id, "every possible type of closed type hierarchy was matched without restrictions"));
 
     public override ImmutableArray<SuppressionDescriptor> SupportedSuppressions { get; } = ImmutableArray.CreateRange(SuppressionDescriptorByDiagnosticId.Values);
-
+    
     public override void ReportSuppressions(SuppressionAnalysisContext context)
     {
         foreach (Diagnostic diagnostic in context.ReportedDiagnostics)
@@ -39,6 +40,8 @@ void HandleDiagnostic(Diagnostic diagnostic)
                     return;
                 }
 
+                bool allowRecords = context.AreRecordHierarchiesAllowed(node.SyntaxTree);
+
                 ExpressionSyntax switchee = switchStatement.Expression;
                 var switcheeModel = context.GetSemanticModel(switchee.SyntaxTree);
                 var switcheeTypeInfo = switcheeModel.GetTypeInfo(switchee);
@@ -47,7 +50,7 @@ void HandleDiagnostic(Diagnostic diagnostic)
                     return;
                 }
 
-                if (TypeHierarchyHelper.InterpretAsClosedTypeHierarchy(switcheeType) is not IEnumerable<INamedTypeSymbol> subtypes)
+                if (TypeHierarchyHelper.InterpretAsClosedTypeHierarchy(switcheeType, allowRecords) is not IEnumerable<INamedTypeSymbol> subtypes)
                 {
                     return;
                 }

ClosedTypeHierarchyDiagnosticSuppressor/TypeHierarchyHelper.cs

@@ -6,7 +6,7 @@ namespace SvSoft.Analyzers.ClosedTypeHerarchyDiagnosticSuppression;
 
 public static class TypeHierarchyHelper
 {
-    public static IEnumerable<INamedTypeSymbol>? InterpretAsClosedTypeHierarchy(INamedTypeSymbol typeSymbol)
+    public static IEnumerable<INamedTypeSymbol>? InterpretAsClosedTypeHierarchy(INamedTypeSymbol typeSymbol, bool allowRecords)
     {
         if (!IsPartOfClosedHierarchy(typeSymbol))
         {
@@ -15,7 +15,7 @@ public static class TypeHierarchyHelper
 
         return GetConcreteSubtypes(typeSymbol);
 
-        static bool IsPartOfClosedHierarchy(INamedTypeSymbol typeSymbol)
+        bool IsPartOfClosedHierarchy(INamedTypeSymbol typeSymbol)
         {
             if (CanBeClosedHierarchyRoot(typeSymbol))
             {
@@ -28,7 +28,7 @@ static bool IsPartOfClosedHierarchy(INamedTypeSymbol typeSymbol)
             return CanBeClosedHierarchyLeaf(typeSymbol);
         }
 
-        static IEnumerable<INamedTypeSymbol> GetConcreteSubtypes(INamedTypeSymbol typeSymbol)
+        IEnumerable<INamedTypeSymbol> GetConcreteSubtypes(INamedTypeSymbol typeSymbol)
         {
             if (CanBeClosedHierarchyRoot(typeSymbol))
             {
@@ -51,10 +51,30 @@ static IEnumerable<INamedTypeSymbol> GetConcreteSubtypes(INamedTypeSymbol typeSy
             }
         }
 
-        static bool CanBeClosedHierarchyRoot(INamedTypeSymbol rootCandidate) =>
+        bool CanBeClosedHierarchyRoot(INamedTypeSymbol rootCandidate) =>
             rootCandidate.IsAbstract &&
+            (allowRecords
+                ? HasOnlyPrivateConstructorsAndProtectedCopyCtors(rootCandidate)
+                : HasOnlyPrivateConstructors(rootCandidate));
+
+        static bool HasOnlyPrivateConstructors(INamedTypeSymbol rootCandidate) =>
             rootCandidate.Constructors.All(c => c.DeclaredAccessibility == Accessibility.Private);
 
+        static bool HasOnlyPrivateConstructorsAndProtectedCopyCtors(INamedTypeSymbol rootCandidate) =>
+            HasOnlyPrivateConstructors(rootCandidate) ||
+            (IsRecord(rootCandidate) &&
+            rootCandidate.Constructors.All(c => c.DeclaredAccessibility == Accessibility.Private || MatchesImplicitlyCreatedRecordCopyCtor(rootCandidate, c)));
+
+        const string CompilerCreatedCloneMethodNameOnRecordTypes = "<Clone>$";
+
+        static bool IsRecord(INamedTypeSymbol recordCandidate) =>
+            recordCandidate.MemberNames.Contains(CompilerCreatedCloneMethodNameOnRecordTypes);
+
+        static bool MatchesImplicitlyCreatedRecordCopyCtor(INamedTypeSymbol constructedType, IMethodSymbol ctor) =>
+            ctor.DeclaredAccessibility == Accessibility.Protected &&
+            ctor.Parameters.Length == 1 &&
+            ctor.Parameters[0].Type.Equals(constructedType, SymbolEqualityComparer.Default);
+
         static bool CanBeClosedHierarchyLeaf(INamedTypeSymbol typeSymbol) => typeSymbol.IsSealed;
     }
 }

README.md

@@ -42,6 +42,12 @@ Get on [nuget.org](https://www.nuget.org/packages/SvSoft.Analyzers.ClosedTypeHie
 There are no attributes and no configuration.
 It will just do The Right Thing™.
 
+The only exception is the configuration for opting into treating type hierarchies based on `record` types as closed, even though [they are not because of their implicit protected copy constructor](https://svenhuebner-it.com/closed-type-hierarchies-with-records-not/).
+
+```
+dotnet_diagnostic.CTH001.suppress_on_record_hierarchies
+```
+
 See the test samples for [switch statement](https://github.com/shuebner/ClosedTypeHierarchyDiagnosticSuppressor/blob/main/ClosedTypeHierarchyDiagnosticSuppressor.Tests/SwitchStatementSuppressorTests.cs) and [switch expression](https://github.com/shuebner/ClosedTypeHierarchyDiagnosticSuppressor/blob/main/ClosedTypeHierarchyDiagnosticSuppressor.Tests/SwitchExpressionSuppressorTests.cs) to see what is supported.
 I may add more documentation and examples in this README soon.