Support target-typed new expressions (#12)

* Recognize ImplicitObjectCreationExpressionSyntax

* Add tests and sample for target-typed new

* Simplify syntax node identification

* Return pattern matching

* Minor improvements cherry picked from 309d875

Cherry picked changes from 309d875

Minor improvements to syntax, null checking and unit test.

---------

Co-authored-by: Andreas Gullberg Larsen <andreas.larsen84@gmail.com>

Author: anserg256

AssignAll/AssignAll.Test/UnitTests.cs

@@ -713,5 +713,36 @@ private class Derived : Base
             var expected = VerifyCS.Diagnostic("AssignAll").WithLocation(0).WithArguments("Derived", "BasePropUnassigned, DerivedPropUnassigned" );
             await VerifyCS.VerifyAnalyzerAsync(test, expected);
         }
+
+        [Fact]
+        public async Task TargetTypedNew_UnassignedMembers_AddsDiagnostic()
+        {
+            var test = @"
+namespace SampleConsoleApp
+{
+    internal static class Program
+    {
+        private static void Main(string[] args)
+        {
+            // AssignAll enable
+            Foo foo = {|#0:new()
+            {
+                // PropString not assigned, diagnostic error
+                PropInt = 1,
+            }|#0};
+        }
+
+        private class Foo
+        {
+            public int PropInt { get; set; }
+            public string PropString { get; set; }
+        }
+    }
+}
+";
+
+            var expected = VerifyCS.Diagnostic("AssignAll").WithLocation(0).WithArguments("Foo", "PropString");
+            await VerifyCS.VerifyAnalyzerAsync(test, expected);
+        }
     }
 }

AssignAll/AssignAll/AssignAllCodeFixProvider.cs

@@ -43,7 +43,7 @@ public sealed override async Task RegisterCodeFixesAsync(CodeFixContext ctx)
                 return;
 
             // Find the object initializer identified by the diagnostic
-            var objectCreation = root.FindNode(diagnosticSpan) as ObjectCreationExpressionSyntax;
+            var objectCreation = root.FindNode(diagnosticSpan) as BaseObjectCreationExpressionSyntax;
             InitializerExpressionSyntax objectInitializer = objectCreation?.Initializer;
             if (objectInitializer == null)
                 return;

AssignAll/AssignAll/AssignAllMembers/ObjectInitializerAnalyzer.cs

@@ -25,15 +25,13 @@ internal void AnalyzeObjectInitializers(SyntaxNodeAnalysisContext ctx)
             // TODO Support other means to enable, such as static configuration (analyze all/none by default), attributes on types and members
             if (!_regionsToAnalyze.TextSpans.Any(enabledTextSpan => enabledTextSpan.Contains(objectInitializer.SpanStart))) return;
 
-            // Only handle initializers immediately following object creation,
-            // not sure what the scenario would be since we are only registered for
+            // Only handle initializers immediately following object creation.
+            // Not sure what the scenario would be since we are only registered for
             // object initializers, not things like list/collection initializers.
-            if (!(objectInitializer.Parent is ObjectCreationExpressionSyntax objectCreation))
+            if (!(objectInitializer.Parent is BaseObjectCreationExpressionSyntax objectCreation))
                 return;
 
-            var objectCreationNamedType =
-                (INamedTypeSymbol) ctx.SemanticModel.GetSymbolInfo(objectCreation.Type).Symbol;
-            if (objectCreationNamedType == null)
+            if (!(ctx.SemanticModel.GetTypeInfo(objectCreation).Type is INamedTypeSymbol objectCreationNamedType))
                 return;
 
             IEnumerable<ISymbol> membersEnumerable = objectCreationNamedType.GetMembers();
@@ -110,20 +108,10 @@ internal void AnalyzeObjectInitializers(SyntaxNodeAnalysisContext ctx)
             }
         }
 
-        // public void CodeBlockEndAction(CodeBlockAnalysisContext ctx)
-        // {
-        // }
-
-        private static ImmutableArray<string> GetIgnoredPropertyNames(ObjectCreationExpressionSyntax objectCreation)
+        private static ImmutableArray<string> GetIgnoredPropertyNames(BaseObjectCreationExpressionSyntax objectCreation)
         {
-            ImmutableArray<string> propertiesByCommentedAssignment =
-                GetIgnoredPropertyNamesFromCommentedAssignments(objectCreation);
-            return propertiesByCommentedAssignment;
-        }
+            if (objectCreation.Initializer == null) return ImmutableArray<string>.Empty;
 
-        private static ImmutableArray<string> GetIgnoredPropertyNamesFromCommentedAssignments(
-            ObjectCreationExpressionSyntax objectCreation)
-        {
             // Case 1: Commented member assignments before one or more actual member assignments
             // return new Foo {
             //   // Prop1 = null,

Samples.ConsoleNet6/Example005_TargetTypedNew.cs

@@ -0,0 +1,25 @@
+// AssignAll enable
+// EXAMPLE 005 - Target-typed new expressions.
+// https://learn.microsoft.com/ru-ru/dotnet/csharp/language-reference/proposals/csharp-9.0/target-typed-new
+namespace Samples.ConsoleNet6;
+
+public static class Example005_TargetTypedNew
+{
+    public static void Irrelevant()
+    {
+        // This should give analyzer error:
+        // Missing member assignments in object initializer for type 'Foo'. Properties: PropUnassigned
+        Foo foo = new()
+        {
+            // Commented assignments after opening brace.
+            // PropCommented1 = 1,
+
+            // Assigned property, OK by analyzer
+            PropAssigned = 1,
+
+            // Commented assignments just before closing brace
+            //PropCommented2 = ,
+            // PropCommented3=,
+        };
+    }
+}