Guard against insupported syntax

Author: fabien.menager

src/EntityFrameworkCore.Projectables.CodeFixes/FactoryMethodTransformationHelper.cs

@@ -347,9 +347,11 @@ private static SyntaxNode BuildRootWithConstructor(
         var initializer = creation.Initializer!;
 
         // Only support simple object-initializer assignments (Prop = value). If there are
-        // other initializer forms (e.g., collection initializers), bail out to avoid
+        // other initializer forms (e.g., collection initializers) or assignments whose RHS
+        // is a nested initializer (e.g. Items = { 1, 2 }), bail out to avoid
         // producing a constructor that does not preserve behavior.
-        if (initializer.Expressions.Any(e => e is not AssignmentExpressionSyntax))
+        if (initializer.Expressions.Any(
+            e => e is not AssignmentExpressionSyntax { Right: not InitializerExpressionSyntax }))
         {
             return root;
         }

src/EntityFrameworkCore.Projectables.CodeFixes/SyntaxHelpers.cs

@@ -54,6 +54,17 @@ static internal bool TryGetFactoryMethodPattern(
             return false;
         }
 
+        // Only pure simple-assignment initializers (Prop = value) — no bare collection
+        // elements (which are not AssignmentExpressionSyntax) and no nested initializer
+        // assignments (Items = { 1, 2 }) whose RHS is an InitializerExpressionSyntax.
+        // Converting such entries to statements would produce invalid C#, so we must not
+        // offer the refactoring at all for these patterns.
+        if (creation.Initializer.Expressions.Any(
+            e => e is not AssignmentExpressionSyntax { Right: not InitializerExpressionSyntax }))
+        {
+            return false;
+        }
+
         // Only allow static factory methods, to keep the code fix simpler
         if (!method.Modifiers.Any(m => m.IsKind(SyntaxKind.StaticKeyword)))
         {

tests/EntityFrameworkCore.Projectables.CodeFixes.Tests/FactoryMethodToCtorCodeFixProviderTests.cs

@@ -130,4 +130,56 @@ class MyObj {
 
         Assert.Empty(actions);
     }
+
+    /// <summary>
+    /// <c>Items = { 1, 2 }</c> in an object initializer is an
+    /// <see cref="Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax"/>
+    /// whose RHS is an <see cref="Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax"/>.
+    /// Converting it to a statement produces invalid C# (<c>Items = { 1, 2 };</c>),
+    /// so the code fix must not be offered for this pattern.
+    /// </summary>
+    [Fact]
+    public async Task NoCodeFix_WhenInitializerHasNestedCollectionInitializer()
+    {
+        var actions = await GetCodeFixActionsAsync(
+            @"
+using System.Collections.Generic;
+namespace Foo {
+    class MyObj {
+        public List<int> Items { get; set; }
+        [Projectable]
+        public static MyObj Create() => new MyObj { Items = { 1, 2 } };
+    }
+}",
+            "EFP0012",
+            FactoryMethodToCtorSources.FirstMethodIdentifierSpan,
+            _provider);
+
+        Assert.Empty(actions);
+    }
+
+    /// <summary>
+    /// A mixed initializer that combines a simple assignment with a nested collection
+    /// initializer (<c>Items = { 1, 2 }</c>) must also be rejected.
+    /// </summary>
+    [Fact]
+    public async Task NoCodeFix_WhenMixedSimpleAndNestedCollectionInitializer()
+    {
+        var actions = await GetCodeFixActionsAsync(
+            @"
+using System.Collections.Generic;
+namespace Foo {
+    class MyObj {
+        public int Value { get; set; }
+        public List<int> Items { get; set; }
+        [Projectable]
+        public static MyObj Create(int v) => new MyObj { Value = v, Items = { 1, 2 } };
+    }
+}",
+            "EFP0012",
+            FactoryMethodToCtorSources.FirstMethodIdentifierSpan,
+            _provider);
+
+        Assert.Empty(actions);
+    }
 }

tests/EntityFrameworkCore.Projectables.CodeFixes.Tests/FactoryMethodToCtorCodeRefProviderTests.cs

@@ -205,6 +205,56 @@ class MyObj {
         Assert.Empty(actions);
     }
 
+    /// <summary>
+    /// <c>Items = { 1, 2 }</c> in an object initializer is an
+    /// <see cref="Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax"/>
+    /// whose RHS is an <see cref="Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax"/>.
+    /// Converting it to a statement produces invalid C# (<c>Items = { 1, 2 };</c>),
+    /// so the refactoring must not be offered for this pattern.
+    /// </summary>
+    [Fact]
+    public async Task NoRefactoring_WhenInitializerHasNestedCollectionInitializer()
+    {
+        var actions = await GetRefactoringActionsAsync(
+            @"
+using System.Collections.Generic;
+namespace Foo {
+    class MyObj {
+        public List<int> Items { get; set; }
+        [Projectable]
+        public static MyObj Create() => new MyObj { Items = { 1, 2 } };
+    }
+}",
+            FactoryMethodToCtorSources.FirstMethodIdentifierSpan,
+            _provider);
+
+        Assert.Empty(actions);
+    }
+
+    /// <summary>
+    /// A mixed initializer that combines a simple assignment with a nested collection
+    /// initializer (<c>Items = { 1, 2 }</c>) must also be rejected.
+    /// </summary>
+    [Fact]
+    public async Task NoRefactoring_WhenMixedSimpleAndNestedCollectionInitializer()
+    {
+        var actions = await GetRefactoringActionsAsync(
+            @"
+using System.Collections.Generic;
+namespace Foo {
+    class MyObj {
+        public int Value { get; set; }
+        public List<int> Items { get; set; }
+        [Projectable]
+        public static MyObj Create(int v) => new MyObj { Value = v, Items = { 1, 2 } };
+    }
+}",
+            FactoryMethodToCtorSources.FirstMethodIdentifierSpan,
+            _provider);
+
+        Assert.Empty(actions);
+    }
+
     /// <summary>
     /// Regression: <c>new Other.MyObj { }</c> has a qualified type name that cannot be
     /// confirmed as the containing type without a semantic model.  The pattern must reject