Update SA1112 for target-typed new

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp9/ReadabilityRules/SA1112CSharp9UnitTests.cs

@@ -3,9 +3,51 @@
 
 namespace StyleCop.Analyzers.Test.CSharp9.ReadabilityRules
 {
+    using System.Threading;
+    using System.Threading.Tasks;
+    using Microsoft.CodeAnalysis.Testing;
     using StyleCop.Analyzers.Test.CSharp8.ReadabilityRules;
+    using StyleCop.Analyzers.Test.Helpers;
+    using Xunit;
+    using static StyleCop.Analyzers.Test.Verifiers.StyleCopCodeFixVerifier<
+        StyleCop.Analyzers.ReadabilityRules.SA1112ClosingParenthesisMustBeOnLineOfOpeningParenthesis,
+        StyleCop.Analyzers.SpacingRules.TokenSpacingCodeFixProvider>;
 
     public partial class SA1112CSharp9UnitTests : SA1112CSharp8UnitTests
     {
+        [Fact]
+        [WorkItem(3972, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3972")]
+        public async Task TestTargetTypedNewClosingParenthesisAsync()
+        {
+            var testCode = @"
+struct TestStruct
+{
+}
+
+class Test
+{
+    void M()
+    {
+        TestStruct value = new(
+            {|#0:)|};
+    }
+}";
+
+            var fixedCode = @"
+struct TestStruct
+{
+}
+
+class Test
+{
+    void M()
+    {
+        TestStruct value = new();
+    }
+}";
+
+            var expected = Diagnostic().WithLocation(0);
+            await VerifyCSharpFixAsync(testCode, expected, fixedCode, CancellationToken.None).ConfigureAwait(false);
+        }
     }
 }

StyleCop.Analyzers/StyleCop.Analyzers/ReadabilityRules/SA1112ClosingParenthesisMustBeOnLineOfOpeningParenthesis.cs

@@ -51,6 +51,7 @@ internal class SA1112ClosingParenthesisMustBeOnLineOfOpeningParenthesis : Diagno
         private static readonly Action<SyntaxNodeAnalysisContext> ConstructorDeclarationAction = HandleConstructorDeclaration;
         private static readonly Action<SyntaxNodeAnalysisContext> InvocationExpressionAction = HandleInvocationExpression;
         private static readonly Action<SyntaxNodeAnalysisContext> ObjectCreationExpressionAction = HandleObjectCreationExpression;
+        private static readonly Action<SyntaxNodeAnalysisContext> ImplicitObjectCreationExpressionAction = HandleImplicitObjectCreationExpression;
 
         /// <inheritdoc/>
         public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } =
@@ -67,6 +68,7 @@ public override void Initialize(AnalysisContext context)
             context.RegisterSyntaxNodeAction(ConstructorDeclarationAction, SyntaxKind.ConstructorDeclaration);
             context.RegisterSyntaxNodeAction(InvocationExpressionAction, SyntaxKind.InvocationExpression);
             context.RegisterSyntaxNodeAction(ObjectCreationExpressionAction, SyntaxKind.ObjectCreationExpression);
+            context.RegisterSyntaxNodeAction(ImplicitObjectCreationExpressionAction, SyntaxKindEx.ImplicitObjectCreationExpression);
         }
 
         private static void HandleObjectCreationExpression(SyntaxNodeAnalysisContext context)
@@ -89,6 +91,28 @@ private static void HandleObjectCreationExpression(SyntaxNodeAnalysisContext con
             }
         }
 
+        private static void HandleImplicitObjectCreationExpression(SyntaxNodeAnalysisContext context)
+        {
+            var implicitObjectCreation = (ImplicitObjectCreationExpressionSyntaxWrapper)context.Node;
+            var argumentList = implicitObjectCreation.ArgumentList;
+
+            if (argumentList == null ||
+                argumentList.IsMissing ||
+                argumentList.Arguments.Count > 0)
+            {
+                return;
+            }
+
+            if (!argumentList.OpenParenToken.IsMissing &&
+                !argumentList.CloseParenToken.IsMissing)
+            {
+                CheckIfLocationOfOpenAndCloseTokensAreTheSame(
+                    context,
+                    argumentList.OpenParenToken,
+                    argumentList.CloseParenToken);
+            }
+        }
+
         private static void HandleInvocationExpression(SyntaxNodeAnalysisContext context)
         {
             var invocationExpression = (InvocationExpressionSyntax)context.Node;

documentation/SA1112.md

@@ -23,6 +23,8 @@ The closing parenthesis or bracket in a call to a C# method or indexer, or the d
 
 A violation of this rule occurs when a method or indexer does not take any parameters and the closing bracket of a call or declaration for the method or indexer is not placed on the same line as the opening bracket. The following example shows correct placement of the closing parenthesis:
 
+This rule applies to calls to constructors and object creation expressions, including target-typed `new()` expressions in C# 9. When no arguments are provided, the closing parenthesis should remain on the same line as the opening parenthesis following `new`.
+
 ```csharp
 public string GetName()
 {