Merge pull request #60 from smoogipoo/settingsource-attribute

Add analyser + codefix for SettingSourceAttribute
ppy · Nov 17, 2023 · 52bb29a · 52bb29a
2 parents c424c56 + 5ee272d
commit 52bb29a
Show file tree

Hide file tree

Showing 14 changed files with 166 additions and 10 deletions.
diff --git a/LocalisationAnalyser.Tests/Analysers/AbstractAnalyserTests.cs b/LocalisationAnalyser.Tests/Analysers/AbstractAnalyserTests.cs
@@ -26,6 +26,7 @@ protected async Task Check(string name)
                 $"{resources_namespace}.ResolvedAttribute.txt",
                 $"{resources_namespace}.LocalisableString.txt",
                 $"{resources_namespace}.TranslatableString.txt",
+                $"{resources_namespace}.SettingSourceAttribute.txt",
             };
 
             foreach (var f in resourceNames.Where(n => n.StartsWith($"{resources_namespace}.Analysers.{name}")))

diff --git a/LocalisationAnalyser.Tests/Analysers/StringCanBeLocalisedAnalyserTests.cs b/LocalisationAnalyser.Tests/Analysers/StringCanBeLocalisedAnalyserTests.cs
@@ -12,6 +12,7 @@ public class StringCanBeLocalisedAnalyserTests : AbstractAnalyserTests<StringCan
         [Theory]
         [InlineData("Attribute")]
         [InlineData("DescriptionAttribute")]
+        [InlineData("SettingSourceAttribute")]
         [InlineData("BasicString")]
         [InlineData("EmptyString")]
         [InlineData("InterpolatedString")]

diff --git a/LocalisationAnalyser.Tests/CodeFixes/AbstractCodeFixProviderTests.cs b/LocalisationAnalyser.Tests/CodeFixes/AbstractCodeFixProviderTests.cs
@@ -23,7 +23,8 @@ public async Task RunTest(string name, bool brokenAnalyserConfigFiles = false)
             {
                 ("LocalisableString.cs", readResourceStream(assembly, $"{resources_namespace}.LocalisableString.txt")),
                 ("TranslatableString.cs", readResourceStream(assembly, $"{resources_namespace}.TranslatableString.txt")),
-                ("LocalisableDescriptionAttribute.cs", readResourceStream(assembly, $"{resources_namespace}.LocalisableDescriptionAttribute.txt"))
+                ("LocalisableDescriptionAttribute.cs", readResourceStream(assembly, $"{resources_namespace}.LocalisableDescriptionAttribute.txt")),
+                ("SettingSourceAttribute.cs", readResourceStream(assembly, $"{resources_namespace}.SettingSourceAttribute.txt")),
             };
 
             var sourceFiles = new List<(string filename, string content)>(requiredFiles);

diff --git a/LocalisationAnalyser.Tests/CodeFixes/LocaliseClassStringCodeFixProviderTests.cs b/LocalisationAnalyser.Tests/CodeFixes/LocaliseClassStringCodeFixProviderTests.cs
@@ -23,6 +23,7 @@ public class LocaliseClassStringCodeFixProviderTests : AbstractCodeFixProviderTe
         [InlineData("DescriptionAttribute")]
         [InlineData("StringWithApostrophe")]
         [InlineData("SequentialCapitals")]
+        [InlineData("SettingSourceAttribute")]
         public async Task Check(string name) => await RunTest(name);
 
         [Theory]

diff --git a/LocalisationAnalyser.Tests/Resources/Analysers/SettingSourceAttribute/Program.txt b/LocalisationAnalyser.Tests/Resources/Analysers/SettingSourceAttribute/Program.txt
@@ -0,0 +1,17 @@
+using osu.Game.Configuration;
+
+namespace Test
+{
+    class Program
+    {
+        [SettingSource(typeof(object), [|"a"|])]
+        [SettingSource(typeof(object), [|"a"|], [|"b"|])]
+        [SettingSource([|"a"|])]
+        [SettingSource([|"a"|], [|"b"|])]
+        [SettingSource(typeof(object), [|"a"|], [|"b"|], 0)]
+        [SettingSource([|"a"|], [|"b"|], 0)]
+        static void Main()
+        {
+        }
+    }
+}
diff --git a/...ser.Tests/Resources/CodeFixes/SettingSourceAttribute/Fixed/Localisation/Class1Strings.txt b/...ser.Tests/Resources/CodeFixes/SettingSourceAttribute/Fixed/Localisation/Class1Strings.txt
@@ -0,0 +1,21 @@
+using osu.Framework.Localisation;
+
+namespace TestProject.Localisation
+{
+    public static class Class1Strings
+    {
+        private const string prefix = @"TestProject.Localisation.Class1";
+
+        /// <summary>
+        /// "abc"
+        /// </summary>
+        public static LocalisableString Abc => new TranslatableString(getKey(@"abc"), @"abc");
+
+        /// <summary>
+        /// "def"
+        /// </summary>
+        public static LocalisableString Def => new TranslatableString(getKey(@"def"), @"def");
+
+        private static string getKey(string key) => $@"{prefix}:{key}";
+    }
+}
diff --git a/LocalisationAnalyser.Tests/Resources/CodeFixes/SettingSourceAttribute/Fixed/Program.txt b/LocalisationAnalyser.Tests/Resources/CodeFixes/SettingSourceAttribute/Fixed/Program.txt
@@ -0,0 +1,13 @@
+using System.ComponentModel;
+using osu.Game.Configuration;
+using TestProject.Localisation;
+
+namespace Test
+{
+    [SettingSource(typeof(Class1Strings), nameof(Class1Strings.Abc))]
+    [SettingSource(typeof(Class1Strings), nameof(Class1Strings.Abc), nameof(Class1Strings.Def))]
+    [SettingSource(typeof(Class1Strings), nameof(Class1Strings.Abc), nameof(Class1Strings.Def), 1)]
+    class Class1
+    {
+    }
+}
diff --git a/...r.Tests/Resources/CodeFixes/SettingSourceAttribute/Sources/Localisation/Class1Strings.txt b/...r.Tests/Resources/CodeFixes/SettingSourceAttribute/Sources/Localisation/Class1Strings.txt
@@ -0,0 +1,21 @@
+using osu.Framework.Localisation;
+
+namespace TestProject.Localisation
+{
+    public static class Class1Strings
+    {
+        private const string prefix = @"TestProject.Localisation.Class1";
+
+        /// <summary>
+        /// "abc"
+        /// </summary>
+        public static LocalisableString Abc => new TranslatableString(getKey(@"abc"), @"abc");
+
+        /// <summary>
+        /// "def"
+        /// </summary>
+        public static LocalisableString Def => new TranslatableString(getKey(@"def"), @"def");
+
+        private static string getKey(string key) => $@"{prefix}:{key}";
+    }
+}
diff --git a/LocalisationAnalyser.Tests/Resources/CodeFixes/SettingSourceAttribute/Sources/Program.txt b/LocalisationAnalyser.Tests/Resources/CodeFixes/SettingSourceAttribute/Sources/Program.txt
@@ -0,0 +1,12 @@
+using System.ComponentModel;
+using osu.Game.Configuration;
+
+namespace Test
+{
+    [SettingSource([|"abc"|])]
+    [SettingSource([|"abc"|], [|"def"|])]
+    [SettingSource([|"abc"|], [|"def"|], 1)]
+    class Class1
+    {
+    }
+}
diff --git a/LocalisationAnalyser.Tests/Resources/SettingSourceAttribute.txt b/LocalisationAnalyser.Tests/Resources/SettingSourceAttribute.txt
@@ -0,0 +1,28 @@
+namespace osu.Game.Configuration
+{
+    [System.AttributeUsage(System.AttributeTargets.All, AllowMultiple = true)]
+    public class SettingSourceAttribute : System.Attribute
+    {
+        public string Label { get; }
+
+        public string Description { get; }
+
+        public SettingSourceAttribute(System.Type declaringType, string label, string? description = null)
+        {
+        }
+
+        public SettingSourceAttribute(string? label, string? description = null)
+        {
+        }
+
+        public SettingSourceAttribute(System.Type declaringType, string label, string description, int orderPosition)
+            : this(declaringType, label, description)
+        {
+        }
+
+        public SettingSourceAttribute(string label, string description, int orderPosition)
+            : this(label, description)
+        {
+        }
+    }
+}
diff --git a/LocalisationAnalyser/Analysers/StringCanBeLocalisedAnalyser.cs b/LocalisationAnalyser/Analysers/StringCanBeLocalisedAnalyser.cs
@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Immutable;
-using System.ComponentModel;
 using System.Linq;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
@@ -19,6 +18,12 @@ public class StringCanBeLocalisedAnalyser : DiagnosticAnalyzer
     {
         public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(DiagnosticRules.STRING_CAN_BE_LOCALISED);
 
+        private static readonly string[] localisable_attributes =
+        {
+            "System.ComponentModel.DescriptionAttribute",
+            "osu.Game.Configuration.SettingSourceAttribute"
+        };
+
         public override void Initialize(AnalysisContext context)
         {
             // See https://github.com/dotnet/roslyn/blob/main/docs/analyzers/Analyzer%20Actions%20Semantics.md for more information
@@ -43,9 +48,9 @@ private void analyseString(SyntaxNodeAnalysisContext context)
                     if (literal.Parent?.Kind() == SyntaxKind.AttributeArgument)
                     {
                         SyntaxNode attributeSyntax = literal.FirstAncestorOrSelf<AttributeSyntax>();
-                        string attributeName = context.SemanticModel.GetSymbolInfo(attributeSyntax).Symbol.ContainingType.ToString();
+                        string attributeName = context.SemanticModel.GetTypeInfo(attributeSyntax).Type.ToString();
 
-                        if (attributeName != typeof(DescriptionAttribute).FullName)
+                        if (!localisable_attributes.Contains(attributeName))
                             return;
                     }
 

diff --git a/LocalisationAnalyser/CodeFixes/AbstractLocaliseStringCodeFixProvider.cs b/LocalisationAnalyser/CodeFixes/AbstractLocaliseStringCodeFixProvider.cs
@@ -230,8 +230,22 @@ private async Task<Solution> addMember(Document document, SyntaxNode nodeToRepla
 
             if (nodeToReplace.Parent.Kind() == SyntaxKind.AttributeArgument)
             {
-                rootNode = rootNode.ReplaceNode(nodeToReplace.FirstAncestorOrSelf<AttributeSyntax>(), SyntaxGenerators.GenerateAttributeAccessSyntax(memberAccess));
-                rootNode = SyntaxGenerators.AddUsingDirectiveIfNotExisting((CompilationUnitSyntax)rootNode, SyntaxTemplates.FRAMEWORK_LOCALISATION_NAMESPACE);
+                AttributeArgumentSyntax argSyntax = (AttributeArgumentSyntax)nodeToReplace.Parent;
+                AttributeSyntax attributeSyntax = nodeToReplace.FirstAncestorOrSelf<AttributeSyntax>();
+                SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken);
+                string attributeName = semanticModel.GetTypeInfo(attributeSyntax).Type.ToString();
+
+                switch (attributeName)
+                {
+                    case "System.ComponentModel.DescriptionAttribute":
+                        rootNode = rootNode.ReplaceNode(attributeSyntax, SyntaxGenerators.GenerateLocalisableDescriptionAttributeAccessSyntax(memberAccess));
+                        rootNode = SyntaxGenerators.AddUsingDirectiveIfNotExisting((CompilationUnitSyntax)rootNode, SyntaxTemplates.FRAMEWORK_LOCALISATION_NAMESPACE);
+                        break;
+
+                    case "osu.Game.Configuration.SettingSourceAttribute":
+                        rootNode = rootNode.ReplaceNode(attributeSyntax, SyntaxGenerators.GenerateSettingSourceAttributeAccessSyntax(attributeSyntax, argSyntax, memberAccess));
+                        break;
+                }
             }
             else
                 rootNode = rootNode.ReplaceNode(nodeToReplace, SyntaxGenerators.GenerateDirectAccessSyntax(memberAccess, parameterValues));

diff --git a/LocalisationAnalyser/Localisation/SyntaxGenerators.cs b/LocalisationAnalyser/Localisation/SyntaxGenerators.cs
@@ -173,20 +173,39 @@ public static ExpressionSyntax GenerateDirectAccessSyntax(MemberAccessExpression
         /// </summary>
         /// <param name="memberAccess">The member to access.</param>
         /// <returns>The <see cref="AttributeSyntax"/>.</returns>
-        public static AttributeSyntax GenerateAttributeAccessSyntax(MemberAccessExpressionSyntax memberAccess)
+        public static AttributeSyntax GenerateLocalisableDescriptionAttributeAccessSyntax(MemberAccessExpressionSyntax memberAccess)
             => SyntaxFactory.Attribute(
-                                SyntaxFactory.IdentifierName(SyntaxTemplates.ATTRIBUTE_CONSTRUCTION_TYPE))
+                                SyntaxFactory.IdentifierName(SyntaxTemplates.LOCALISABLE_DESCRIPTION_ATTRIBUTE_CONSTRUCTION_TYPE))
                             .WithArgumentList(
                                 SyntaxFactory.AttributeArgumentList(
                                     SyntaxFactory.SeparatedList(new[]
                                         {
                                             SyntaxFactory.AttributeArgument(
-                                                SyntaxFactory.TypeOfExpression(((IdentifierNameSyntax)memberAccess.Expression))),
+                                                SyntaxFactory.TypeOfExpression((IdentifierNameSyntax)memberAccess.Expression)),
                                             SyntaxFactory.AttributeArgument(
                                                 SyntaxFactory.ParseExpression($"nameof({memberAccess.Expression}.{memberAccess.Name})"))
                                         }
                                     )));
 
+        public static AttributeSyntax GenerateSettingSourceAttributeAccessSyntax(AttributeSyntax attributeToReplace, AttributeArgumentSyntax argToReplace, MemberAccessExpressionSyntax memberAccess)
+        {
+            List<AttributeArgumentSyntax> newArguments =
+                attributeToReplace.ArgumentList.Arguments
+                                  .Select(arg => arg == argToReplace
+                                      ? SyntaxFactory.AttributeArgument(
+                                          SyntaxFactory.ParseExpression($"nameof({memberAccess.Expression}.{memberAccess.Name})"))
+                                      : arg).ToList();
+
+            if (newArguments.First().Expression is not TypeOfExpressionSyntax)
+                newArguments.Insert(0, SyntaxFactory.AttributeArgument(SyntaxFactory.TypeOfExpression((IdentifierNameSyntax)memberAccess.Expression)));
+
+            return SyntaxFactory.Attribute(
+                                    SyntaxFactory.IdentifierName(SyntaxTemplates.SETTING_SOURCE_ATTRIBUTE_CONSTRUCTION_TYPE))
+                                .WithArgumentList(
+                                    SyntaxFactory.AttributeArgumentList(
+                                        SyntaxFactory.SeparatedList(newArguments)));
+        }
+
         /// <summary>
         /// Checks for and adds a new using directive to the given <see cref="CompilationUnitSyntax"/> if required.
         /// </summary>

diff --git a/LocalisationAnalyser/Localisation/SyntaxTemplates.cs b/LocalisationAnalyser/Localisation/SyntaxTemplates.cs
@@ -23,7 +23,9 @@ public static class SyntaxTemplates
         /// <summary>
         /// The construction type of the localisable attribute which replaces <see cref="System.ComponentModel.DescriptionAttribute"/>.
         /// </summary>
-        public const string ATTRIBUTE_CONSTRUCTION_TYPE = "LocalisableDescription";
+        public const string LOCALISABLE_DESCRIPTION_ATTRIBUTE_CONSTRUCTION_TYPE = "LocalisableDescription";
+
+        public const string SETTING_SOURCE_ATTRIBUTE_CONSTRUCTION_TYPE = "SettingSource";
 
         /// <summary>
         /// The path to localisations relative to the project directory.