Merge pull request #68612 from CyrusNajmabadi/usePrimaryDirectives

Fix 'use primary constructor' in the presence of directives

Author: CyrusNajmabadi

src/Analyzers/CSharp/Analyzers/UsePrimaryConstructor/CSharpUsePrimaryConstructorDiagnosticAnalyzer.cs

@@ -11,12 +11,10 @@
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
-using System.Security.Cryptography;
 using System.Threading;
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
-using Microsoft.CodeAnalysis.CSharp.LanguageService;
 using Microsoft.CodeAnalysis.CSharp.Shared.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
@@ -381,12 +379,17 @@ bool AnalyzeConstructorBody(
                     Dictionary<ISymbol, IParameterSymbol> candidateMembersToRemove)
                 {
                     var semanticModel = compilation.GetSemanticModel(primaryConstructorDeclaration.SyntaxTree);
+
+                    var body = primaryConstructorDeclaration.ExpressionBody ?? (SyntaxNode?)primaryConstructorDeclaration.Body;
+                    if (body?.ContainsDirectives is true)
+                        return false;
+
                     return primaryConstructorDeclaration switch
                     {
                         { ExpressionBody.Expression: AssignmentExpressionSyntax assignmentExpression }
                             => IsAssignmentToInstanceMember(namedType, semanticModel, assignmentExpression, candidateMembersToRemove, out _),
-                        { Body: { } body }
-                            => AnalyzeBlockBody(namedType, semanticModel, body, candidateMembersToRemove),
+                        { Body: { } block }
+                            => AnalyzeBlockBody(namedType, semanticModel, block, candidateMembersToRemove),
                         _ => false,
                     };
                 }

src/Analyzers/CSharp/Tests/UsePrimaryConstructor/UsePrimaryConstructorTests.cs

@@ -2606,4 +2606,270 @@ class C(int i)
             LanguageVersion = LanguageVersion.Preview,
         }.RunAsync();
     }
+
+    [Fact]
+    public async Task TestNotWithPreprocessorRegion1()
+    {
+        await new VerifyCS.Test
+        {
+            TestCode = """
+                using System;
+
+                class C
+                {
+                    public C(int i)
+                    {
+                #if NET6
+                        Console.WriteLine();
+                #endif
+                    }
+                }
+                """,
+            LanguageVersion = LanguageVersion.Preview,
+        }.RunAsync();
+    }
+
+    [Fact]
+    public async Task TestNotWithPreprocessorRegion2()
+    {
+        await new VerifyCS.Test
+        {
+            TestCode = """
+                using System;
+
+                class C
+                {
+                    public C(int i)
+                    {
+                #if false
+                        Console.WriteLine();
+                #endif
+                    }
+                }
+                """,
+            LanguageVersion = LanguageVersion.Preview,
+        }.RunAsync();
+    }
+
+    [Fact]
+    public async Task TestNotWithPreprocessorRegion3()
+    {
+        await new VerifyCS.Test
+        {
+            TestCode = """
+                using System;
+
+                class C
+                {
+                    private int _i;
+
+                    public C(int i)
+                #if NET6
+                        => _i = i;
+                #else
+                        => this._i = i;
+                #endif
+                }
+                """,
+            LanguageVersion = LanguageVersion.Preview,
+        }.RunAsync();
+    }
+
+    [Fact]
+    public async Task TestNotWithPreprocessorRegion4()
+    {
+        await new VerifyCS.Test
+        {
+            TestCode = """
+                using System;
+
+                class C
+                {
+                    private int _i;
+
+                    public C(int i)
+                #if true
+                        => _i = i;
+                #else
+                        => this._i = i;
+                #endif
+                }
+                """,
+            LanguageVersion = LanguageVersion.Preview,
+        }.RunAsync();
+    }
+
+    [Fact]
+    public async Task TestNotWithPreprocessorRegion5()
+    {
+        await new VerifyCS.Test
+        {
+            TestCode = """
+                using System;
+
+                class C
+                {
+                    private int _i;
+
+                    public C(int i)
+                #if false
+                        => _i = i;
+                #else
+                        => this._i = i;
+                #endif
+                }
+                """,
+            LanguageVersion = LanguageVersion.Preview,
+        }.RunAsync();
+    }
+
+    [Fact]
+    public async Task TestNotWithPreprocessorRegion6()
+    {
+        await new VerifyCS.Test
+        {
+            TestCode = """
+                using System;
+
+                class C
+                {
+                    private int _i;
+
+                    public C(int i)
+                    {
+                #if true
+                        _i = i;
+                #endif
+                    }
+                }
+                """,
+            LanguageVersion = LanguageVersion.Preview,
+        }.RunAsync();
+    }
+
+    [Fact]
+    public async Task TestNotWithPreprocessorRegion7()
+    {
+        await new VerifyCS.Test
+        {
+            TestCode = """
+                using System;
+
+                class C
+                {
+                    private int _i;
+
+                    public C(int i)
+                    {
+                #if true
+                        _i = i;
+                #else
+                        this._i = i;
+                #endif
+                    }
+                }
+                """,
+            LanguageVersion = LanguageVersion.Preview,
+        }.RunAsync();
+    }
+
+    [Fact]
+    public async Task TestNotWithPreprocessorRegion8()
+    {
+        await new VerifyCS.Test
+        {
+            TestCode = """
+                using System;
+
+                class C
+                {
+                    private int _i;
+
+                    public C(int i)
+                    {
+                #if false
+                        _i = i;
+                #else
+                        this._i = i;
+                #endif
+                    }
+                }
+                """,
+            LanguageVersion = LanguageVersion.Preview,
+        }.RunAsync();
+    }
+
+    [Fact]
+    public async Task TestWithRegionDirective1()
+    {
+        await new VerifyCS.Test
+        {
+            TestCode = """
+                class C
+                {
+
+                    #region constructors
+
+                    public [|C|](int i)
+                    {
+                    }
+
+                    #endregion
+
+                }
+                """,
+            FixedCode = """
+                class C(int i)
+                {
+                
+                    #region constructors
+
+                    #endregion
+
+                }
+                """,
+            LanguageVersion = LanguageVersion.Preview,
+        }.RunAsync();
+    }
+
+    [Fact]
+    public async Task TestWithRegionDirective2()
+    {
+        await new VerifyCS.Test
+        {
+            TestCode = """
+                class C
+                {
+
+                    #region constructors
+
+                    public [|C|](int i)
+                    {
+                    }
+
+                    public C(string s) : this(s.Length)
+                    {
+                    }
+
+                    #endregion
+
+                }
+                """,
+            FixedCode = """
+                class C(int i)
+                {
+
+                    #region constructors
+
+                    public C(string s) : this(s.Length)
+                    {
+                    }
+
+                    #endregion
+
+                }
+                """,
+            LanguageVersion = LanguageVersion.Preview,
+        }.RunAsync();
+    }
 }