Support implicit object creation expressions in SA1129 code fix

StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/ReadabilityRules/SA1129CodeFixProvider.cs

@@ -15,7 +15,9 @@ namespace StyleCop.Analyzers.ReadabilityRules
     using Microsoft.CodeAnalysis.CodeFixes;
     using Microsoft.CodeAnalysis.CSharp;
     using Microsoft.CodeAnalysis.CSharp.Syntax;
+    using Microsoft.CodeAnalysis.Editing;
     using StyleCop.Analyzers.Helpers;
+    using StyleCop.Analyzers.Lightup;
 
     /// <summary>
     /// Implements a code fix for <see cref="SA1129DoNotUseDefaultValueTypeConstructor"/>.
@@ -54,17 +56,19 @@ private static async Task<Document> GetTransformedDocumentAsync(Document documen
             var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
 
             var newExpression = syntaxRoot.FindNode(diagnostic.Location.SourceSpan, getInnermostNodeForTie: true);
-            var newSyntaxRoot = syntaxRoot.ReplaceNode(newExpression, GetReplacementNode(newExpression, semanticModel, cancellationToken));
+            var newSyntaxRoot = syntaxRoot.ReplaceNode(newExpression, GetReplacementNode(document.Project, newExpression, semanticModel, cancellationToken));
 
             return document.WithSyntaxRoot(newSyntaxRoot);
         }
 
-        private static SyntaxNode GetReplacementNode(SyntaxNode node, SemanticModel semanticModel, CancellationToken cancellationToken)
+        private static SyntaxNode GetReplacementNode(Project project, SyntaxNode node, SemanticModel semanticModel, CancellationToken cancellationToken)
         {
-            var newExpression = (ObjectCreationExpressionSyntax)node;
+            var newExpression = (BaseObjectCreationExpressionSyntaxWrapper)node;
 
-            var symbolInfo = semanticModel.GetSymbolInfo(newExpression.Type, cancellationToken);
-            var namedTypeSymbol = symbolInfo.Symbol as INamedTypeSymbol;
+            var symbolInfo = semanticModel.GetSymbolInfo(newExpression, cancellationToken);
+            var namedTypeSymbol = (symbolInfo.Symbol as IMethodSymbol)?.ContainingType;
+
+            var type = GetOrCreateTypeSyntax(project, newExpression, namedTypeSymbol);
 
             SyntaxNode replacement;
 
@@ -75,7 +79,7 @@ private static SyntaxNode GetReplacementNode(SyntaxNode node, SemanticModel sema
             {
                 if (IsDefaultParameterValue(newExpression))
                 {
-                    replacement = SyntaxFactory.DefaultExpression(newExpression.Type);
+                    replacement = SyntaxFactory.DefaultExpression(type);
                 }
                 else
                 {
@@ -98,21 +102,34 @@ private static SyntaxNode GetReplacementNode(SyntaxNode node, SemanticModel sema
                         fieldName = nameof(Guid.Empty);
                     }
 
-                    replacement = ConstructMemberAccessSyntax(newExpression.Type, fieldName);
+                    replacement = ConstructMemberAccessSyntax(type, fieldName);
                 }
             }
             else if (IsEnumWithDefaultMember(namedTypeSymbol, out string memberName))
             {
-                replacement = ConstructMemberAccessSyntax(newExpression.Type, memberName);
+                replacement = ConstructMemberAccessSyntax(type, memberName);
             }
             else
             {
-                replacement = SyntaxFactory.DefaultExpression(newExpression.Type);
+                replacement = SyntaxFactory.DefaultExpression(type);
             }
 
             return replacement
-                .WithLeadingTrivia(newExpression.GetLeadingTrivia())
-                .WithTrailingTrivia(newExpression.GetTrailingTrivia());
+                .WithLeadingTrivia(newExpression.SyntaxNode.GetLeadingTrivia())
+                .WithTrailingTrivia(newExpression.SyntaxNode.GetTrailingTrivia());
+        }
+
+        private static TypeSyntax GetOrCreateTypeSyntax(Project project, BaseObjectCreationExpressionSyntaxWrapper baseObjectCreationExpression, INamedTypeSymbol constructedType)
+        {
+            if (baseObjectCreationExpression.SyntaxNode is ObjectCreationExpressionSyntax objectCreationExpressionSyntax)
+            {
+                return objectCreationExpressionSyntax.Type;
+            }
+            else
+            {
+                SyntaxGenerator generator = SyntaxGenerator.GetGenerator(project);
+                return (TypeSyntax)generator.TypeExpression(constructedType);
+            }
         }
 
         /// <summary>
@@ -146,9 +163,9 @@ private static bool IsType<T>(INamedTypeSymbol namedTypeSymbol)
             return true;
         }
 
-        private static bool IsDefaultParameterValue(ObjectCreationExpressionSyntax expression)
+        private static bool IsDefaultParameterValue(BaseObjectCreationExpressionSyntaxWrapper expression)
         {
-            if (expression.Parent.Parent is ParameterSyntax parameterSyntax)
+            if (expression.SyntaxNode.Parent.Parent is ParameterSyntax parameterSyntax)
             {
                 return parameterSyntax.Parent.Parent is BaseMethodDeclarationSyntax;
             }
@@ -221,7 +238,7 @@ protected override async Task<SyntaxNode> FixAllInDocumentAsync(FixAllContext fi
 
                 var nodes = diagnostics.Select(diagnostic => syntaxRoot.FindNode(diagnostic.Location.SourceSpan, getInnermostNodeForTie: true));
 
-                return syntaxRoot.ReplaceNodes(nodes, (originalNode, rewrittenNode) => GetReplacementNode(rewrittenNode, semanticModel, fixAllContext.CancellationToken));
+                return syntaxRoot.ReplaceNodes(nodes, (originalNode, rewrittenNode) => GetReplacementNode(document.Project, rewrittenNode, semanticModel, fixAllContext.CancellationToken));
             }
         }
     }

StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs

@@ -861,7 +861,6 @@ private void GenerateSyntaxWrapperHelper(in GeneratorExecutionContext context, I
                                                     SyntaxFactory.IdentifierName("Type"),
                                                 })))))))))));
 
-            bool first = true;
             foreach (var node in wrapperTypes.OrderBy(node => node.Name, StringComparer.OrdinalIgnoreCase))
             {
                 if (node.WrapperName is null)
@@ -924,8 +923,67 @@ private void GenerateSyntaxWrapperHelper(in GeneratorExecutionContext context, I
                     continue;
                 }
 
+                if (node.Name == nameof(BaseObjectCreationExpressionSyntax))
+                {
+                    // Prior to C# 9, ObjectCreationExpressionSyntax was the base type for all object creation
+                    // statements. If the BaseObjectCreationExpressionSyntax type isn't found at runtime, we fall back
+                    // to using this type instead.
+                    //
+                    // var objectCreationExpressionSyntaxType = csharpCodeAnalysisAssembly.GetType(BaseObjectCreationExpressionSyntaxWrapper.WrappedTypeName)
+                    //     ?? csharpCodeAnalysisAssembly.GetType(BaseObjectCreationExpressionSyntaxWrapper.FallbackWrappedTypeName);
+                    LocalDeclarationStatementSyntax localStatement =
+                        SyntaxFactory.LocalDeclarationStatement(SyntaxFactory.VariableDeclaration(
+                            type: SyntaxFactory.IdentifierName("var"),
+                            variables: SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator(
+                                identifier: SyntaxFactory.Identifier("objectCreationExpressionSyntaxType"),
+                                argumentList: null,
+                                initializer: SyntaxFactory.EqualsValueClause(
+                                    SyntaxFactory.BinaryExpression(
+                                        SyntaxKind.CoalesceExpression,
+                                        left: SyntaxFactory.InvocationExpression(
+                                            expression: SyntaxFactory.MemberAccessExpression(
+                                                SyntaxKind.SimpleMemberAccessExpression,
+                                                expression: SyntaxFactory.IdentifierName("csharpCodeAnalysisAssembly"),
+                                                name: SyntaxFactory.IdentifierName("GetType")),
+                                            argumentList: SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(
+                                                SyntaxFactory.MemberAccessExpression(
+                                                    SyntaxKind.SimpleMemberAccessExpression,
+                                                    expression: SyntaxFactory.IdentifierName(node.WrapperName),
+                                                    name: SyntaxFactory.IdentifierName("WrappedTypeName")))))),
+                                        right: SyntaxFactory.InvocationExpression(
+                                            expression: SyntaxFactory.MemberAccessExpression(
+                                                SyntaxKind.SimpleMemberAccessExpression,
+                                                expression: SyntaxFactory.IdentifierName("csharpCodeAnalysisAssembly"),
+                                                name: SyntaxFactory.IdentifierName("GetType")),
+                                            argumentList: SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(
+                                                SyntaxFactory.MemberAccessExpression(
+                                                    SyntaxKind.SimpleMemberAccessExpression,
+                                                    expression: SyntaxFactory.IdentifierName(node.WrapperName),
+                                                    name: SyntaxFactory.IdentifierName("FallbackWrappedTypeName"))))))))))));
+
+                    // This is the first line of the statements that initialize 'builder', so start it with a blank line
+                    staticCtorStatements = staticCtorStatements.Add(localStatement.WithLeadingBlankLine());
+
+                    // builder.Add(typeof(BaseObjectCreationExpressionSyntaxWrapper), objectCreationExpressionSyntaxType);
+                    staticCtorStatements = staticCtorStatements.Add(SyntaxFactory.ExpressionStatement(
+                        SyntaxFactory.InvocationExpression(
+                            expression: SyntaxFactory.MemberAccessExpression(
+                                SyntaxKind.SimpleMemberAccessExpression,
+                                expression: SyntaxFactory.IdentifierName("builder"),
+                                name: SyntaxFactory.IdentifierName("Add")),
+                            argumentList: SyntaxFactory.ArgumentList(
+                                SyntaxFactory.SeparatedList(
+                                    new[]
+                                    {
+                                        SyntaxFactory.Argument(SyntaxFactory.TypeOfExpression(SyntaxFactory.IdentifierName(node.WrapperName))),
+                                        SyntaxFactory.Argument(SyntaxFactory.IdentifierName("objectCreationExpressionSyntaxType")),
+                                    })))));
+
+                    continue;
+                }
+
                 // builder.Add(typeof(ConstantPatternSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(ConstantPatternSyntaxWrapper.WrappedTypeName));
-                ExpressionStatementSyntax statement = SyntaxFactory.ExpressionStatement(
+                staticCtorStatements = staticCtorStatements.Add(SyntaxFactory.ExpressionStatement(
                     SyntaxFactory.InvocationExpression(
                         expression: SyntaxFactory.MemberAccessExpression(
                             SyntaxKind.SimpleMemberAccessExpression,
@@ -947,15 +1005,7 @@ private void GenerateSyntaxWrapperHelper(in GeneratorExecutionContext context, I
                                                     SyntaxKind.SimpleMemberAccessExpression,
                                                     expression: SyntaxFactory.IdentifierName(node.WrapperName),
                                                     name: SyntaxFactory.IdentifierName("WrappedTypeName"))))))),
-                                }))));
-
-                if (first)
-                {
-                    statement = statement.WithLeadingBlankLine();
-                    first = false;
-                }
-
-                staticCtorStatements = staticCtorStatements.Add(statement);
+                                })))));
             }
 
             // WrappedTypes = builder.ToImmutable();

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

@@ -3,9 +3,46 @@
 
 namespace StyleCop.Analyzers.Test.CSharp9.ReadabilityRules
 {
+    using System.Threading;
+    using System.Threading.Tasks;
+    using Microsoft.CodeAnalysis.Testing;
     using StyleCop.Analyzers.Test.CSharp8.ReadabilityRules;
+    using Xunit;
+    using static StyleCop.Analyzers.Test.Verifiers.StyleCopCodeFixVerifier<
+        StyleCop.Analyzers.ReadabilityRules.SA1129DoNotUseDefaultValueTypeConstructor,
+        StyleCop.Analyzers.ReadabilityRules.SA1129CodeFixProvider>;
 
     public class SA1129CSharp9UnitTests : SA1129CSharp8UnitTests
     {
+        /// <summary>
+        /// Verifies that target type new expressions for value types will generate diagnostics.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        [Fact]
+        [WorkItem(3277, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3277")]
+        public async Task VerifyValueTypeWithTargetTypeNewAsync()
+        {
+            var testCode = @"struct S
+{
+    internal static S F()
+    {
+        S s = [|new()|];
+        return s;
+    }
+}
+";
+
+            var fixedTestCode = @"struct S
+{
+    internal static S F()
+    {
+        S s = default(S);
+        return s;
+    }
+}
+";
+
+            await VerifyCSharpFixAsync(testCode, DiagnosticResult.EmptyDiagnosticResults, fixedTestCode, CancellationToken.None).ConfigureAwait(false);
+        }
     }
 }

StyleCop.Analyzers/StyleCop.Analyzers.Test/Lightup/SyntaxWrapperHelperTests.cs

@@ -44,6 +44,12 @@ public void VerifyThatWrapperClassIsPresent(Type wrapperType)
                 Assert.False(LightupHelpers.SupportsCSharp7);
                 Assert.Same(typeof(ForEachStatementSyntax), SyntaxWrapperHelper.GetWrappedType(wrapperType));
             }
+            else if (wrapperType == typeof(BaseObjectCreationExpressionSyntaxWrapper))
+            {
+                // Special case for C# 6-8 analysis compatibility
+                Assert.False(LightupHelpers.SupportsCSharp9);
+                Assert.Same(typeof(ObjectCreationExpressionSyntax), SyntaxWrapperHelper.GetWrappedType(wrapperType));
+            }
             else
             {
                 Assert.Null(SyntaxWrapperHelper.GetWrappedType(wrapperType));

StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SyntaxWrapperHelper.g.cs

@@ -18,7 +18,8 @@ static SyntaxWrapperHelper()
             var csharpCodeAnalysisAssembly = typeof(CSharpSyntaxNode).GetTypeInfo().Assembly;
             var builder = ImmutableDictionary.CreateBuilder<Type, Type>();
 
-            builder.Add(typeof(BaseObjectCreationExpressionSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(BaseObjectCreationExpressionSyntaxWrapper.WrappedTypeName));
+            var objectCreationExpressionSyntaxType = csharpCodeAnalysisAssembly.GetType(BaseObjectCreationExpressionSyntaxWrapper.WrappedTypeName) ?? csharpCodeAnalysisAssembly.GetType(BaseObjectCreationExpressionSyntaxWrapper.FallbackWrappedTypeName);
+            builder.Add(typeof(BaseObjectCreationExpressionSyntaxWrapper), objectCreationExpressionSyntaxType);
             builder.Add(typeof(BaseParameterSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(BaseParameterSyntaxWrapper.WrappedTypeName));
             builder.Add(typeof(BinaryPatternSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(BinaryPatternSyntaxWrapper.WrappedTypeName));
             builder.Add(typeof(CasePatternSwitchLabelSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(CasePatternSwitchLabelSyntaxWrapper.WrappedTypeName));

StyleCop.Analyzers/StyleCop.Analyzers/Lightup/BaseObjectCreationExpressionSyntaxWrapper.cs

@@ -0,0 +1,17 @@
+// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+namespace StyleCop.Analyzers.Lightup
+{
+    using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+    internal partial struct BaseObjectCreationExpressionSyntaxWrapper : ISyntaxWrapper<ExpressionSyntax>
+    {
+        internal const string FallbackWrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax";
+
+        public static implicit operator BaseObjectCreationExpressionSyntaxWrapper(ObjectCreationExpressionSyntax node)
+        {
+            return new BaseObjectCreationExpressionSyntaxWrapper(node);
+        }
+    }
+}