Add rule to detect non-readonly struct used for in or ref readonly parameters

README.md

@@ -183,6 +183,7 @@ If you are already using other analyzers, you can check [which rules are duplica
 |[MA0165](https://github.com/meziantou/Meziantou.Analyzer/blob/main/docs/Rules/MA0165.md)|Usage|Make interpolated string|👻|✔️|✔️|
 |[MA0166](https://github.com/meziantou/Meziantou.Analyzer/blob/main/docs/Rules/MA0166.md)|Usage|Forward the TimeProvider to methods that take one|ℹ️|✔️|✔️|
 |[MA0167](https://github.com/meziantou/Meziantou.Analyzer/blob/main/docs/Rules/MA0167.md)|Usage|Use an overload with a TimeProvider argument|ℹ️|❌|❌|
+|[MA0168](https://github.com/meziantou/Meziantou.Analyzer/blob/main/docs/Rules/MA0168.md)|Performance|Use readonly struct for in or ref readonly parameter|ℹ️|❌|❌|
 
 <!-- rules -->
 

docs/README.md

@@ -167,6 +167,7 @@
 |[MA0165](https://github.com/meziantou/Meziantou.Analyzer/blob/main/docs/Rules/MA0165.md)|Usage|Make interpolated string|<span title='Hidden'>👻</span>|✔️|✔️|
 |[MA0166](https://github.com/meziantou/Meziantou.Analyzer/blob/main/docs/Rules/MA0166.md)|Usage|Forward the TimeProvider to methods that take one|<span title='Info'>ℹ️</span>|✔️|✔️|
 |[MA0167](https://github.com/meziantou/Meziantou.Analyzer/blob/main/docs/Rules/MA0167.md)|Usage|Use an overload with a TimeProvider argument|<span title='Info'>ℹ️</span>|❌|❌|
+|[MA0168](https://github.com/meziantou/Meziantou.Analyzer/blob/main/docs/Rules/MA0168.md)|Performance|Use readonly struct for in or ref readonly parameter|<span title='Info'>ℹ️</span>|❌|❌|
 
 |Id|Suppressed rule|Justification|
 |--|---------------|-------------|
@@ -676,6 +677,9 @@ dotnet_diagnostic.MA0166.severity = suggestion
 
 # MA0167: Use an overload with a TimeProvider argument
 dotnet_diagnostic.MA0167.severity = none
+
+# MA0168: Use readonly struct for in or ref readonly parameter
+dotnet_diagnostic.MA0168.severity = none
 ```
 
 # .editorconfig - all rules disabled
@@ -1178,4 +1182,7 @@ dotnet_diagnostic.MA0166.severity = none
 
 # MA0167: Use an overload with a TimeProvider argument
 dotnet_diagnostic.MA0167.severity = none
+
+# MA0168: Use readonly struct for in or ref readonly parameter
+dotnet_diagnostic.MA0168.severity = none
 ```

docs/Rules/MA0168.md

@@ -0,0 +1,13 @@
+# MA0168 - Use readonly struct for in or ref readonly parameter
+
+```c#
+void A(in Foo p) { } // not-compliant as Foo is not readonly
+
+struct Foo { }
+```
+
+```c#
+void A(in Foo p) { } // ok
+
+readonly struct Foo { }
+```

src/Meziantou.Analyzer.Pack/configuration/default.editorconfig

@@ -499,3 +499,6 @@ dotnet_diagnostic.MA0166.severity = suggestion
 
 # MA0167: Use an overload with a TimeProvider argument
 dotnet_diagnostic.MA0167.severity = none
+
+# MA0168: Use readonly struct for in or ref readonly parameter
+dotnet_diagnostic.MA0168.severity = none

src/Meziantou.Analyzer.Pack/configuration/none.editorconfig

@@ -499,3 +499,6 @@ dotnet_diagnostic.MA0166.severity = none
 
 # MA0167: Use an overload with a TimeProvider argument
 dotnet_diagnostic.MA0167.severity = none
+
+# MA0168: Use readonly struct for in or ref readonly parameter
+dotnet_diagnostic.MA0168.severity = none

src/Meziantou.Analyzer/RuleIdentifiers.cs

@@ -170,6 +170,7 @@ internal static class RuleIdentifiers
     public const string MakeInterpolatedString = "MA0165";
     public const string UseAnOverloadThatHasTimeProviderWhenAvailable = "MA0166";
     public const string UseAnOverloadThatHasTimeProvider = "MA0167";
+    public const string UseReadOnlyStructForRefReadOnlyParameters = "MA0168";
 
     public static string GetHelpUri(string identifier)
     {

src/Meziantou.Analyzer/Rules/UseReadOnlyStructForRefReadOnlyParametersAnalyzer.cs

@@ -0,0 +1,86 @@
+#if ROSLYN_4_8_OR_GREATER
+using System.Collections.Immutable;
+using Meziantou.Analyzer.Internals;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Operations;
+
+namespace Meziantou.Analyzer.Rules;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class UseReadOnlyStructForRefReadOnlyParametersAnalyzer : DiagnosticAnalyzer
+{
+    private static readonly DiagnosticDescriptor Rule = new(
+        RuleIdentifiers.UseReadOnlyStructForRefReadOnlyParameters,
+        title: "Use readonly struct for in or ref readonly parameter",
+        messageFormat: "Use readonly struct for in or ref readonly parameter",
+        RuleCategories.Performance,
+        DiagnosticSeverity.Info,
+        isEnabledByDefault: false,
+        description: "",
+        helpLinkUri: RuleIdentifiers.GetHelpUri(RuleIdentifiers.UseReadOnlyStructForRefReadOnlyParameters));
+
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);
+
+    public override void Initialize(AnalysisContext context)
+    {
+        context.EnableConcurrentExecution();
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+
+        context.RegisterSymbolAction(context =>
+        {
+            var parameter = (IParameterSymbol)context.Symbol;
+            if (!IsValidParameter(parameter))
+            {
+                context.ReportDiagnostic(Rule, parameter);
+            }
+
+        }, SymbolKind.Parameter);
+
+        context.RegisterOperationAction(context =>
+        {
+            var operation = (ILocalFunctionOperation)context.Operation;
+            var symbol = operation.Symbol;
+            foreach (var parameter in symbol.Parameters)
+            {
+                if (!IsValidParameter(parameter))
+                {
+                    context.ReportDiagnostic(Rule, parameter);
+                }
+            }
+
+        }, OperationKind.LocalFunction);
+
+        context.RegisterOperationAction(ctx =>
+        {
+            var operation = (IArgumentOperation)ctx.Operation;
+            var parameter = operation.Parameter;
+            if (parameter is null)
+                return;
+
+            // Do not report non-generic types as they are reported by SymbolAction
+            if (SymbolEqualityComparer.Default.Equals(parameter.OriginalDefinition.Type, parameter.Type))
+                return;
+
+            if (!IsValidParameter(parameter))
+            {
+                ctx.ReportDiagnostic(Rule, operation);
+            }
+        }, OperationKind.Argument);
+    }
+
+    private static bool IsValidParameter(IParameterSymbol parameter)
+    {
+        if (parameter.RefKind is RefKind.In or RefKind.RefReadOnlyParameter)
+        {
+            if (parameter.Type is INamedTypeSymbol namedTypeSymbol)
+            {
+                if (namedTypeSymbol.IsValueType && !namedTypeSymbol.IsReadOnly)
+                    return false;
+            }
+        }
+
+        return true;
+    }
+}
+#endif

tests/Meziantou.Analyzer.Test/Rules/UseReadOnlyStructForRefReadOnlyParametersAnalyzerTests.cs

@@ -0,0 +1,96 @@
+#if ROSLYN_4_8_OR_GREATER
+using System.Threading.Tasks;
+using Meziantou.Analyzer.Rules;
+using TestHelper;
+using Xunit;
+
+namespace Meziantou.Analyzer.Test.Rules;
+
+public class UseReadOnlyStructForRefReadOnlyParametersAnalyzerTests
+{
+    private static ProjectBuilder CreateProjectBuilder()
+    {
+        return new ProjectBuilder()
+            .WithOutputKind(Microsoft.CodeAnalysis.OutputKind.ConsoleApplication)
+            .WithAnalyzer<UseReadOnlyStructForRefReadOnlyParametersAnalyzer>();
+    }
+
+    [Fact]
+    public async Task ParameterNotRefReadOnly()
+    {
+        await CreateProjectBuilder()
+              .WithSourceCode("""
+                  A(default);
+
+                  void A(Foo foo) { }
+                  struct Foo { }
+                  """)
+              .ValidateAsync();
+    }
+
+    [Fact]
+    public async Task StructNotReadOnly_in()
+    {
+        await CreateProjectBuilder()
+              .WithSourceCode("""              
+                  A(default);
+
+                  void A(in Foo [|foo|]) { }
+                  struct Foo { }
+                  """)
+              .ValidateAsync();
+    }
+
+    [Fact]
+    public async Task StructNotReadOnly_ref_readonly()
+    {
+        await CreateProjectBuilder()
+              .WithSourceCode("""              
+                  A(default);
+
+                  void A(ref readonly Foo [|foo|]) { }
+                  struct Foo { }
+                  """)
+              .ValidateAsync();
+    }
+
+    [Fact]
+    public async Task StructReadOnly()
+    {
+        await CreateProjectBuilder()
+              .WithSourceCode("""              
+                  A(default);
+
+                  void A(in Foo foo) { }
+                  readonly struct Foo { }
+                  """)
+              .ValidateAsync();
+    }
+
+    [Fact]
+    public async Task StructNotReadOnly_Generic()
+    {
+        await CreateProjectBuilder()
+              .WithSourceCode("""              
+                  A([|new Foo()|]);
+
+                  void A<T>(in T foo) where T: struct { }
+                  struct Foo { }
+                  """)
+              .ValidateAsync();
+    }
+
+    [Fact]
+    public async Task StructReadOnly_Generic()
+    {
+        await CreateProjectBuilder()
+              .WithSourceCode("""              
+                  A(new Foo());
+
+                  void A<T>(in T foo) where T: struct { }
+                  readonly struct Foo { }
+                  """)
+              .ValidateAsync();
+    }
+}
+#endif