DEMO: Localization source generators and analyzers

Flow.Launcher.Analyzers/AnalyzerDiagnostics.cs

@@ -0,0 +1,52 @@
+using Microsoft.CodeAnalysis;
+
+namespace Flow.Launcher.Analyzers
+{
+    public static class AnalyzerDiagnostics
+    {
+        public static readonly DiagnosticDescriptor OldLocalizationApiUsed = new DiagnosticDescriptor(
+            "FLAN0001",
+            "Old localization API used",
+            "Use `Localize.{0}({1})` instead",
+            "Localization",
+            DiagnosticSeverity.Warning,
+            isEnabledByDefault: true
+        );
+
+        public static readonly DiagnosticDescriptor ContextIsAField = new DiagnosticDescriptor(
+            "FLAN0002",
+            "Plugin context is a field",
+            "Plugin context must be at least internal static property",
+            "Localization",
+            DiagnosticSeverity.Error,
+            isEnabledByDefault: true
+        );
+
+        public static readonly DiagnosticDescriptor ContextIsNotStatic = new DiagnosticDescriptor(
+            "FLAN0003",
+            "Plugin context is not static",
+            "Plugin context must be at least internal static property",
+            "Localization",
+            DiagnosticSeverity.Error,
+            isEnabledByDefault: true
+        );
+
+        public static readonly DiagnosticDescriptor ContextAccessIsTooRestrictive = new DiagnosticDescriptor(
+            "FLAN0004",
+            "Plugin context property access modifier is too restrictive",
+            "Plugin context property must be at least internal static property",
+            "Localization",
+            DiagnosticSeverity.Error,
+            isEnabledByDefault: true
+        );
+
+        public static readonly DiagnosticDescriptor ContextIsNotDeclared = new DiagnosticDescriptor(
+            "FLAN0005",
+            "Plugin context is not declared",
+            "Plugin context must be at least internal static property of type `PluginInitContext`",
+            "Localization",
+            DiagnosticSeverity.Error,
+            isEnabledByDefault: true
+        );
+    }
+}

Flow.Launcher.Analyzers/AnalyzerReleases.Shipped.md

@@ -0,0 +1,2 @@
+; Shipped analyzer releases
+; https://github.com/dotnet/roslyn-analyzers/blob/main/src/Microsoft.CodeAnalysis.Analyzers/ReleaseTrackingAnalyzers.Help.md

Flow.Launcher.Analyzers/AnalyzerReleases.Unshipped.md

@@ -0,0 +1,11 @@
+; Unshipped analyzer release
+; https://github.com/dotnet/roslyn-analyzers/blob/main/src/Microsoft.CodeAnalysis.Analyzers/ReleaseTrackingAnalyzers.Help.md
+### New Rules
+
+Rule ID | Category | Severity | Notes
+--------|----------|----------|-------
+FLAN0001 | Localization | Warning | FLAN0001_OldLocalizationApiUsed
+FLAN0002 | Localization | Error | FLAN0002_ContextIsAField
+FLAN0003 | Localization | Error | FLAN0003_ContextIsNotStatic
+FLAN0004 | Localization | Error | FLAN0004_ContextAccessIsTooRestrictive
+FLAN0005 | Localization | Error | FLAN0005_ContextIsNotDeclared

Flow.Launcher.Analyzers/Flow.Launcher.Analyzers.csproj

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <Version>1.0.0</Version>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <EnforceExtendedAnalyzerRules>true</EnforceExtendedAnalyzerRules>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.4">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.9.2"/>
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="4.9.2"/>
+  </ItemGroup>
+
+</Project>

Flow.Launcher.Analyzers/Localize/ContextAvailabilityAnalyzer.cs

@@ -0,0 +1,94 @@
+using System.Collections.Immutable;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace Flow.Launcher.Analyzers.Localize
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class ContextAvailabilityAnalyzer : DiagnosticAnalyzer
+    {
+        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(
+            AnalyzerDiagnostics.ContextIsAField,
+            AnalyzerDiagnostics.ContextIsNotStatic,
+            AnalyzerDiagnostics.ContextAccessIsTooRestrictive,
+            AnalyzerDiagnostics.ContextIsNotDeclared
+        );
+
+        private const string PluginContextTypeName = "PluginInitContext";
+
+        private const string PluginInterfaceName = "IPluginI18n";
+
+        public override void Initialize(AnalysisContext context)
+        {
+            context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.Analyze | GeneratedCodeAnalysisFlags.ReportDiagnostics);
+            context.EnableConcurrentExecution();
+            context.RegisterSyntaxNodeAction(AnalyzeNode, SyntaxKind.ClassDeclaration);
+        }
+
+        private static void AnalyzeNode(SyntaxNodeAnalysisContext context)
+        {
+            var classDeclaration = (ClassDeclarationSyntax)context.Node;
+            var semanticModel = context.SemanticModel;
+            var classSymbol = semanticModel.GetDeclaredSymbol(classDeclaration);
+
+            if (!IsPluginEntryClass(classSymbol)) return;
+
+            var contextProperty = classDeclaration.Members.OfType<PropertyDeclarationSyntax>()
+                .Select(p => semanticModel.GetDeclaredSymbol(p))
+                .FirstOrDefault(p => p?.Type.Name is PluginContextTypeName);
+
+            if (contextProperty != null)
+            {
+                if (!contextProperty.IsStatic)
+                {
+                    context.ReportDiagnostic(Diagnostic.Create(
+                        AnalyzerDiagnostics.ContextIsNotStatic,
+                        contextProperty.DeclaringSyntaxReferences[0].GetSyntax().GetLocation()
+                    ));
+                    return;
+                }
+
+                if (contextProperty.DeclaredAccessibility is Accessibility.Private || contextProperty.DeclaredAccessibility is Accessibility.Protected)
+                {
+                    context.ReportDiagnostic(Diagnostic.Create(
+                        AnalyzerDiagnostics.ContextAccessIsTooRestrictive,
+                        contextProperty.DeclaringSyntaxReferences[0].GetSyntax().GetLocation()
+                    ));
+                    return;
+                }
+
+                return;
+            }
+
+            var fieldDeclaration = classDeclaration.Members
+                .OfType<FieldDeclarationSyntax>()
+                .SelectMany(f => f.Declaration.Variables)
+                .Select(f => semanticModel.GetDeclaredSymbol(f))
+                .FirstOrDefault(f => f is IFieldSymbol fs && fs.Type.Name is PluginContextTypeName);
+            var parentSyntax = fieldDeclaration
+                ?.DeclaringSyntaxReferences[0]
+                .GetSyntax()
+                .FirstAncestorOrSelf<FieldDeclarationSyntax>();
+
+            if (parentSyntax != null)
+            {
+                context.ReportDiagnostic(Diagnostic.Create(
+                    AnalyzerDiagnostics.ContextIsAField,
+                    parentSyntax.GetLocation()
+                ));
+                return;
+            }
+
+            context.ReportDiagnostic(Diagnostic.Create(
+                AnalyzerDiagnostics.ContextIsNotDeclared,
+                classDeclaration.Identifier.GetLocation()
+            ));
+        }
+
+        private static bool IsPluginEntryClass(INamedTypeSymbol namedTypeSymbol) =>
+            namedTypeSymbol?.Interfaces.Any(i => i.Name == PluginInterfaceName) ?? false;
+    }
+}

Flow.Launcher.Analyzers/Localize/ContextAvailabilityAnalyzerCodeFixProvider.cs

@@ -0,0 +1,188 @@
+using System.Collections.Immutable;
+using System.Composition;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Formatting;
+using Microsoft.CodeAnalysis.Simplification;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Flow.Launcher.Analyzers.Localize
+{
+    [ExportCodeFixProvider(LanguageNames.CSharp, Name = nameof(ContextAvailabilityAnalyzerCodeFixProvider)), Shared]
+    public class ContextAvailabilityAnalyzerCodeFixProvider : CodeFixProvider
+    {
+        public sealed override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(
+            AnalyzerDiagnostics.ContextIsAField.Id,
+            AnalyzerDiagnostics.ContextIsNotStatic.Id,
+            AnalyzerDiagnostics.ContextAccessIsTooRestrictive.Id,
+            AnalyzerDiagnostics.ContextIsNotDeclared.Id
+        );
+
+        public sealed override FixAllProvider GetFixAllProvider()
+        {
+            return WellKnownFixAllProviders.BatchFixer;
+        }
+
+        public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
+        {
+            var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+
+            var diagnostic = context.Diagnostics.First();
+            var diagnosticSpan = diagnostic.Location.SourceSpan;
+
+            if (diagnostic.Id == AnalyzerDiagnostics.ContextIsAField.Id)
+            {
+                context.RegisterCodeFix(
+                    CodeAction.Create(
+                        title: "Replace with static property",
+                        createChangedDocument: _ => Task.FromResult(FixContextIsAFieldError(context, root, diagnosticSpan)),
+                        equivalenceKey: AnalyzerDiagnostics.ContextIsAField.Id
+                    ),
+                    diagnostic
+                );
+            }
+            else if (diagnostic.Id == AnalyzerDiagnostics.ContextIsNotStatic.Id)
+            {
+                context.RegisterCodeFix(
+                    CodeAction.Create(
+                        title: "Make static",
+                        createChangedDocument: _ => Task.FromResult(FixContextIsNotStaticError(context, root, diagnosticSpan)),
+                        equivalenceKey: AnalyzerDiagnostics.ContextIsNotStatic.Id
+                    ),
+                    diagnostic
+                );
+            }
+            else if (diagnostic.Id == AnalyzerDiagnostics.ContextAccessIsTooRestrictive.Id)
+            {
+                context.RegisterCodeFix(
+                    CodeAction.Create(
+                        title: "Make internal",
+                        createChangedDocument: _ => Task.FromResult(FixContextIsTooRestricted(context, root, diagnosticSpan)),
+                        equivalenceKey: AnalyzerDiagnostics.ContextAccessIsTooRestrictive.Id
+                    ),
+                    diagnostic
+                );
+            }
+            else if (diagnostic.Id == AnalyzerDiagnostics.ContextIsNotDeclared.Id)
+            {
+                context.RegisterCodeFix(
+                    CodeAction.Create(
+                        title: "Declare context property",
+                        createChangedDocument: _ => Task.FromResult(FixContextNotDeclared(context, root, diagnosticSpan)),
+                        equivalenceKey: AnalyzerDiagnostics.ContextIsNotDeclared.Id
+                    ),
+                    diagnostic
+                );
+            }
+        }
+
+        private static MemberDeclarationSyntax GetStaticContextPropertyDeclaration(string propertyName = "Context") =>
+            SyntaxFactory.ParseMemberDeclaration(
+                $"internal static PluginInitContext {propertyName} {{ get; private set; }} = null!;"
+            );
+
+        private static Document GetFormattedDocument(CodeFixContext context, SyntaxNode root)
+        {
+            var formattedRoot = Formatter.Format(
+                root,
+                Formatter.Annotation,
+                context.Document.Project.Solution.Workspace
+            );
+
+            return context.Document.WithSyntaxRoot(formattedRoot);
+        }
+
+        private static Document FixContextNotDeclared(CodeFixContext context, SyntaxNode root, TextSpan diagnosticSpan)
+        {
+            var classDeclaration = GetDeclarationSyntax<ClassDeclarationSyntax>(root, diagnosticSpan);
+            if (classDeclaration?.BaseList is null) return context.Document;
+
+            var newPropertyDeclaration = GetStaticContextPropertyDeclaration();
+            if (newPropertyDeclaration is null) return context.Document;
+
+            var annotatedNewPropertyDeclaration = newPropertyDeclaration
+                .WithLeadingTrivia(SyntaxFactory.ElasticLineFeed)
+                .WithTrailingTrivia(SyntaxFactory.ElasticLineFeed)
+                .WithAdditionalAnnotations(Formatter.Annotation, Simplifier.Annotation);
+
+            var newMembers = classDeclaration.Members.Insert(0, annotatedNewPropertyDeclaration);
+            var newClassDeclaration = classDeclaration.WithMembers(newMembers);
+
+            var newRoot = root.ReplaceNode(classDeclaration, newClassDeclaration);
+
+            return GetFormattedDocument(context, newRoot);
+        }
+
+        private static Document FixContextIsNotStaticError(CodeFixContext context, SyntaxNode root, TextSpan diagnosticSpan)
+        {
+            var propertyDeclaration = GetDeclarationSyntax<PropertyDeclarationSyntax>(root, diagnosticSpan);
+            if (propertyDeclaration is null) return context.Document;
+
+            var newPropertyDeclaration = FixRestrictivePropertyModifiers(propertyDeclaration).AddModifiers(SyntaxFactory.Token(SyntaxKind.StaticKeyword));
+
+            var newRoot = root.ReplaceNode(propertyDeclaration, newPropertyDeclaration);
+            return context.Document.WithSyntaxRoot(newRoot);
+        }
+
+        private static Document FixContextIsTooRestricted(CodeFixContext context, SyntaxNode root, TextSpan diagnosticSpan)
+        {
+            var propertyDeclaration = GetDeclarationSyntax<PropertyDeclarationSyntax>(root, diagnosticSpan);
+            if (propertyDeclaration is null) return context.Document;
+
+            var newPropertyDeclaration = FixRestrictivePropertyModifiers(propertyDeclaration);
+
+            var newRoot = root.ReplaceNode(propertyDeclaration, newPropertyDeclaration);
+            return context.Document.WithSyntaxRoot(newRoot);
+        }
+
+        private static Document FixContextIsAFieldError(CodeFixContext context, SyntaxNode root, TextSpan diagnosticSpan) {
+            var fieldDeclaration = GetDeclarationSyntax<FieldDeclarationSyntax>(root, diagnosticSpan);
+            if (fieldDeclaration is null) return context.Document;
+
+            var field = fieldDeclaration.Declaration.Variables.First();
+            var fieldIdentifier = field.Identifier.ToString();
+
+            var propertyDeclaration = GetStaticContextPropertyDeclaration(fieldIdentifier);
+            if (propertyDeclaration is null) return context.Document;
+
+            var annotatedNewPropertyDeclaration = propertyDeclaration
+                .WithTriviaFrom(fieldDeclaration)
+                .WithAdditionalAnnotations(Formatter.Annotation, Simplifier.Annotation);
+
+            var newRoot = root.ReplaceNode(fieldDeclaration, annotatedNewPropertyDeclaration);
+
+            return GetFormattedDocument(context, newRoot);
+        }
+
+        private static PropertyDeclarationSyntax FixRestrictivePropertyModifiers(PropertyDeclarationSyntax propertyDeclaration)
+        {
+            var newModifiers = SyntaxFactory.TokenList();
+            foreach (var modifier in propertyDeclaration.Modifiers)
+            {
+                if (modifier.IsKind(SyntaxKind.PrivateKeyword) || modifier.IsKind(SyntaxKind.ProtectedKeyword))
+                {
+                    newModifiers = newModifiers.Add(SyntaxFactory.Token(SyntaxKind.InternalKeyword));
+                }
+                else
+                {
+                    newModifiers = newModifiers.Add(modifier);
+                }
+            }
+
+            return propertyDeclaration.WithModifiers(newModifiers);
+        }
+
+        private static T GetDeclarationSyntax<T>(SyntaxNode root, TextSpan diagnosticSpan) where T : SyntaxNode =>
+            root
+                .FindToken(diagnosticSpan.Start)
+                .Parent
+                ?.AncestorsAndSelf()
+                .OfType<T>()
+                .First();
+    }
+}