Improve MA0084 to detect primary constructor parameters (#656)

Author: meziantou

src/Meziantou.Analyzer/Rules/LocalVariablesShouldNotHideSymbolsAnalyzer.cs

@@ -1,6 +1,8 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Threading;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Operations;
@@ -41,7 +43,7 @@ private static void AnalyzeVariableDeclaration(OperationAnalysisContext context)
         if (containingType == null)
             return;
 
-        foreach (var member in GetSymbols(containingType, localSymbol.Name))
+        foreach (var member in GetSymbols(containingType, localSymbol.Name, context.CancellationToken))
         {
             if (!semanticModel.IsAccessible(operation.Syntax.SpanStart, member))
                 continue;
@@ -57,6 +59,12 @@ private static void AnalyzeVariableDeclaration(OperationAnalysisContext context)
                 ReportDiagnostic("property");
                 return;
             }
+
+            if (member is IParameterSymbol && !operation.IsInStaticContext(context.CancellationToken))
+            {
+                ReportDiagnostic("parameter");
+                return;
+            }
         }
 
         void ReportDiagnostic(string type)
@@ -72,8 +80,32 @@ void ReportDiagnostic(string type)
         }
     }
 
-    private static IEnumerable<ISymbol> GetSymbols(INamedTypeSymbol? type, string name)
+    private static IEnumerable<ISymbol> GetSymbols(INamedTypeSymbol? type, string name, CancellationToken cancellationToken)
     {
+#if CSHARP12_OR_GREATER
+        if (type?.InstanceConstructors is not null)
+        {
+            foreach (var constructor in type.InstanceConstructors)
+            {
+                if (constructor.Parameters.Length == 0)
+                    continue;
+
+                foreach (var syntaxRef in constructor.DeclaringSyntaxReferences)
+                {
+                    var syntax = syntaxRef.GetSyntax(cancellationToken);
+                    if (syntax.IsKind(SyntaxKind.ClassDeclaration) || syntax.IsKind(SyntaxKind.StructDeclaration))
+                    {
+                        var typeDeclaration = (TypeDeclarationSyntax)syntax;
+                        foreach (var param in constructor.Parameters)
+                        {
+                            yield return param;
+                        }
+                    }
+                }
+            }
+        }
+#endif
+
         while (type != null)
         {
             var members = type.GetMembers(name);

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

@@ -70,6 +70,44 @@ await CreateProjectBuilder()
               .ValidateAsync();
     }
 
+#if CSHARP12_OR_GREATER
+    [Fact]
+    public async Task LocalVariableHidePrimaryConstructorParameter()
+    {
+        const string SourceCode = """
+            class Test(int a)
+            {
+                void A()
+                {
+                    var [|a|] = 10;
+                }
+            }
+            """;
+        await CreateProjectBuilder()
+              .WithLanguageVersion(Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp12)
+              .WithSourceCode(SourceCode)
+              .ValidateAsync();
+    }
+
+    [Fact]
+    public async Task LocalVariableDoesNotHidePrimaryConstructorParameterInStaticMethod()
+    {
+        const string SourceCode = """
+            class Test(int a)
+            {
+                static void A()
+                {
+                    var a = 10;
+                }
+            }
+            """;
+        await CreateProjectBuilder()
+              .WithLanguageVersion(Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp12)
+              .WithSourceCode(SourceCode)
+              .ValidateAsync();
+    }
+#endif
+
     [Fact]
     public async Task LocalVariableHideNotVisibleFieldFromParentClass()
     {