Add code fix for public types in Support to make internal

Author: paulirwin

.globalconfig

@@ -0,0 +1,2 @@
+roslyn_correctness.assembly_reference_validation = relaxed
+

src/Lucene.Net.CodeAnalysis.Dev/Lucene.Net.CodeAnalysis.Dev.csproj

@@ -18,6 +18,7 @@
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.12.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="4.12.0" />
   </ItemGroup>
 
   <ItemGroup>

src/Lucene.Net.CodeAnalysis.Dev/LuceneDev1005_LuceneNetSupportPublicTypesCSCodeFix.cs

@@ -0,0 +1,83 @@
+using System.Collections.Immutable;
+using System.Composition;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Rename;
+using SyntaxFactory = Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
+using SyntaxKind = Microsoft.CodeAnalysis.CSharp.SyntaxKind;
+
+namespace Lucene.Net.CodeAnalysis.Dev;
+
+[ExportCodeFixProvider(LanguageNames.CSharp, Name = nameof(LuceneDev1005_LuceneNetSupportPublicTypesCSCodeFix)), Shared]
+public class LuceneDev1005_LuceneNetSupportPublicTypesCSCodeFix : CodeFixProvider
+{
+    // Specify the diagnostic IDs of analyzers that are expected to be linked.
+    public sealed override ImmutableArray<string> FixableDiagnosticIds { get; } =
+        [LuceneDev1005_LuceneNetSupportPublicTypesCSCodeAnalyzer.DiagnosticId];
+
+    public override FixAllProvider? GetFixAllProvider() => WellKnownFixAllProviders.BatchFixer;
+
+    public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
+    {
+        // We link only one diagnostic and assume there is only one diagnostic in the context.
+        var diagnostic = context.Diagnostics.Single();
+
+        // 'SourceSpan' of 'Location' is the highlighted area. We're going to use this area to find the 'SyntaxNode' to rename.
+        var diagnosticSpan = diagnostic.Location.SourceSpan;
+
+        // Get the root of Syntax Tree that contains the highlighted diagnostic.
+        var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+
+        // Find SyntaxNode corresponding to the diagnostic.
+        var diagnosticNode = root?.FindNode(diagnosticSpan);
+
+        if (diagnosticNode is MemberDeclarationSyntax declaration)
+        {
+            var name = declaration switch
+            {
+                BaseTypeDeclarationSyntax baseTypeDeclaration => baseTypeDeclaration.Identifier.ToString(),
+                DelegateDeclarationSyntax delegateDeclaration => delegateDeclaration.Identifier.ToString(),
+                _ => null
+            };
+
+            if (string.IsNullOrEmpty(name))
+            {
+                return;
+            }
+
+            // Register a code action that will invoke the fix.
+            context.RegisterCodeFix(
+                CodeAction.Create(
+                    title: string.Format(Resources.LuceneDev1005_CodeFixTitle, name),
+                    createChangedSolution: c => MakeDeclarationInternal(context.Document, declaration, c),
+                    equivalenceKey: nameof(Resources.LuceneDev1005_CodeFixTitle)),
+                diagnostic);
+        }
+    }
+
+    private async Task<Solution> MakeDeclarationInternal(Document document,
+        MemberDeclarationSyntax memberDeclaration,
+        CancellationToken cancellationToken)
+    {
+        var syntaxRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+        if (syntaxRoot == null) return document.Project.Solution;
+
+        // Remove existing accessibility modifiers
+        var newModifiers = SyntaxFactory.TokenList(
+                memberDeclaration.Modifiers
+                .Where(modifier => !modifier.IsKind(SyntaxKind.PrivateKeyword) &&
+                                   !modifier.IsKind(SyntaxKind.ProtectedKeyword) &&
+                                   !modifier.IsKind(SyntaxKind.InternalKeyword) &&
+                                   !modifier.IsKind(SyntaxKind.PublicKeyword))
+            ).Insert(0, SyntaxFactory.Token(SyntaxKind.InternalKeyword)); // Ensure 'internal' is the first modifier
+
+        var newMemberDeclaration = memberDeclaration.WithModifiers(newModifiers);
+        var newRoot = syntaxRoot.ReplaceNode(memberDeclaration, newMemberDeclaration);
+        return document.Project.Solution.WithDocumentSyntaxRoot(document.Id, newRoot);
+    }
+}

src/Lucene.Net.CodeAnalysis.Dev/Resources.Designer.cs

@@ -186,4 +186,7 @@
   <data name="LuceneDev1005_AnalyzerMessageFormat" xml:space="preserve">
     <value>{0} '{1}' should not have public accessibility in the Support namespace</value>
   </data>
+  <data name="LuceneDev1005_CodeFixTitle" xml:space="preserve">
+    <value>Make {0} internal</value>
+  </data>
 </root>

src/Lucene.Net.CodeAnalysis.Dev/Resources.resx

@@ -0,0 +1,40 @@
+using Lucene.Net.CodeAnalysis.Dev;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.Diagnostics;
+using NUnit.Framework;
+using TestHelper;
+
+namespace Lucene.Net.Tests.CodeAnalysis.Dev;
+
+public class TestLuceneDev1005_LuceneNetSupportPublicTypesCSCodeFix : CodeFixVerifier
+{
+    protected override DiagnosticAnalyzer GetCSharpDiagnosticAnalyzer()
+        => new LuceneDev1005_LuceneNetSupportPublicTypesCSCodeAnalyzer();
+
+    protected override CodeFixProvider GetCSharpCodeFixProvider()
+        => new LuceneDev1005_LuceneNetSupportPublicTypesCSCodeFix();
+
+    [Test]
+    public void PublicTypeInSupport_MakeInternalFix()
+    {
+        const string text =
+            """
+            namespace Lucene.Net.Support;
+            
+            public class MyClass
+            {
+            }
+            """;
+
+        const string newText =
+            """
+            namespace Lucene.Net.Support;
+            
+            internal class MyClass
+            {
+            }
+            """;
+
+        VerifyCSharpFix(text, newText);
+    }
+}