diff --git a/ChangeLog.md b/ChangeLog.md
index ed9b65a368..400de8f52b 100644
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -14,12 +14,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - Make analyzer [RCS0014](https://josefpihrt.github.io/docs/roslynator/analyzers/RCS0014) obsolete
 - Add code fix "Declare as nullable" ([PR](/~https://github.com/dotnet/roslynator/pull/1333))
   - Applicable to: `CS8600`, `CS8610`, `CS8765` and `CS8767`
+- Add option `roslynator_use_collection_expression = true|false` ([PR](/~https://github.com/dotnet/roslynator/pull/1325))
+  - Applicable to [RCS1014](https://josefpihrt.github.io/docs/roslynator/analyzers/RCS1014) and [RCS1250](https://josefpihrt.github.io/docs/roslynator/analyzers/RCS1250)
 
 ### Changed
 
 - Replace type declaration's empty braces with semicolon ([RCS1251](https://josefpihrt.github.io/docs/roslynator/analyzers/RCS1251) ([PR](/~https://github.com/dotnet/roslynator/pull/1323), [PR](/~https://github.com/dotnet/roslynator/pull/1327))
 - [TestFramework] Bump `MSTest.TestFramerk` to `3.1.1` ([PR](/~https://github.com/dotnet/roslynator/pull/1332))
 - [TestFramework] Bump `xunit.assert` to `2.6.2` ([PR](/~https://github.com/dotnet/roslynator/pull/1332))
+- Bump Roslyn to 4.7.0 ([PR](/~https://github.com/dotnet/roslynator/pull/1325))
 
 ## [4.7.0] - 2023-12-03
 
diff --git a/src/Analyzers.CodeFixes/CSharp/CodeFixes/UseExplicitlyOrImplicitlyTypedArrayCodeFixProvider.cs b/src/Analyzers.CodeFixes/CSharp/CodeFixes/UseExplicitlyOrImplicitlyTypedArrayCodeFixProvider.cs
index 9a0bdd8231..da9be67985 100644
--- a/src/Analyzers.CodeFixes/CSharp/CodeFixes/UseExplicitlyOrImplicitlyTypedArrayCodeFixProvider.cs
+++ b/src/Analyzers.CodeFixes/CSharp/CodeFixes/UseExplicitlyOrImplicitlyTypedArrayCodeFixProvider.cs
@@ -12,7 +12,9 @@
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Roslynator.CodeFixes;
+using Roslynator.CSharp.Analysis;
 using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
+using static Roslynator.CSharp.SyntaxRefactorings;
 
 namespace Roslynator.CSharp.CodeFixes;
 
@@ -20,6 +22,10 @@ namespace Roslynator.CSharp.CodeFixes;
 [Shared]
 public sealed class UseExplicitlyOrImplicitlyTypedArrayCodeFixProvider : BaseCodeFixProvider
 {
+    private const string UseExplicitlyTypedArrayTitle = "Use explicit type";
+    private const string UseImplicitlyTypedArrayTitle = "Use implicit type";
+    private const string UseCollectionExpressionTitle = "Use collection expression";
+
     public override ImmutableArray<string> FixableDiagnosticIds
     {
         get { return ImmutableArray.Create(DiagnosticIdentifiers.UseExplicitlyOrImplicitlyTypedArray); }
@@ -28,79 +34,105 @@ public override ImmutableArray<string> FixableDiagnosticIds
     public override FixAllProvider GetFixAllProvider()
     {
         return FixAllProvider.Create(async (context, document, diagnostics) => await FixAllAsync(document, diagnostics, context.CancellationToken).ConfigureAwait(false));
-    }
 
-    private static async Task<Document> FixAllAsync(Document document, ImmutableArray<Diagnostic> diagnostics, CancellationToken cancellationToken)
-    {
-        foreach (Diagnostic diagnostic in diagnostics.OrderByDescending(d => d.Location.SourceSpan.Start))
+        static async Task<Document> FixAllAsync(
+            Document document,
+            ImmutableArray<Diagnostic> diagnostics,
+            CancellationToken cancellationToken)
         {
-            document = await ApplyFixToDocumentAsync(document, diagnostic, cancellationToken).ConfigureAwait(false);
-        }
+            foreach (Diagnostic diagnostic in diagnostics.OrderByDescending(d => d.Location.SourceSpan.Start))
+            {
+                (Func<CancellationToken, Task<Document>> CreateChangedDocument, string) result
+                    = await GetChangedDocumentAsync(document, diagnostic, cancellationToken).ConfigureAwait(false);
 
-        return document;
+                document = await result.CreateChangedDocument(cancellationToken).ConfigureAwait(false);
+            }
+
+            return document;
+        }
     }
 
     public override async Task RegisterCodeFixesAsync(CodeFixContext context)
     {
-        SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
-
-        if (!TryFindFirstAncestorOrSelf(
-            root,
-            context.Span,
-            out SyntaxNode node,
-            predicate: f => f.IsKind(SyntaxKind.ImplicitArrayCreationExpression, SyntaxKind.ArrayCreationExpression)))
-        {
-            return;
-        }
-
         Document document = context.Document;
         Diagnostic diagnostic = context.Diagnostics[0];
 
-        string title = node switch
-        {
-            ImplicitArrayCreationExpressionSyntax => "Use explicitly typed array",
-            ArrayCreationExpressionSyntax => "Use implicitly typed array",
-            _ => throw new InvalidOperationException(),
-        };
+        (Func<CancellationToken, Task<Document>> CreateChangedDocument, string Title)
+            = await GetChangedDocumentAsync(document, diagnostic, context.CancellationToken).ConfigureAwait(false);
 
         CodeAction codeAction = CodeAction.Create(
-            title,
-            ct => ApplyFixToDocumentAsync(document, diagnostic, ct),
-            GetEquivalenceKey(diagnostic));
+            Title,
+            ct => CreateChangedDocument(ct),
+            GetEquivalenceKey(diagnostic, (Title == UseCollectionExpressionTitle) ? "UseCollectionExpression" : null));
 
         context.RegisterCodeFix(codeAction, diagnostic);
     }
 
-    public static async Task<Document> ApplyFixToDocumentAsync(Document document, Diagnostic diag, CancellationToken cancellationToken)
+    private static async Task<(Func<CancellationToken, Task<Document>>, string)> GetChangedDocumentAsync(
+        Document document,
+        Diagnostic diagnostic,
+        CancellationToken cancellationToken)
     {
         SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
 
         if (!TryFindFirstAncestorOrSelf(
             root,
-            diag.Location.SourceSpan,
+            diagnostic.Location.SourceSpan,
             out SyntaxNode node,
-            predicate: f => f.IsKind(SyntaxKind.ImplicitArrayCreationExpression, SyntaxKind.ArrayCreationExpression)))
+            predicate: f => f.IsKind(
+                SyntaxKind.ImplicitArrayCreationExpression,
+                SyntaxKind.ArrayCreationExpression,
+                SyntaxKind.CollectionExpression)))
         {
-            return null;
+            throw new InvalidOperationException();
         }
 
-        return node switch
+        if (node is ArrayCreationExpressionSyntax arrayCreation)
+        {
+            if (diagnostic.Properties.ContainsKey(DiagnosticPropertyKeys.ExplicitToCollectionExpression))
+            {
+                return (ct => ConvertToCollectionExpressionAsync(document, arrayCreation, ct), UseCollectionExpressionTitle);
+            }
+            else
+            {
+                return (ct => ConvertToImplicitAsync(document, arrayCreation, ct), UseImplicitlyTypedArrayTitle);
+            }
+        }
+        else if (node is ImplicitArrayCreationExpressionSyntax implicitArrayCreation)
+        {
+            if (diagnostic.Properties.ContainsKey(DiagnosticPropertyKeys.ImplicitToCollectionExpression))
+            {
+                return (ct => ConvertToCollectionExpressionAsync(document, implicitArrayCreation, ct), UseCollectionExpressionTitle);
+            }
+            else
+            {
+                return (ct => ConvertToExplicitAsync(document, implicitArrayCreation, ct), UseExplicitlyTypedArrayTitle);
+            }
+        }
+        else if (node is CollectionExpressionSyntax collectionExpression)
+        {
+            if (diagnostic.Properties.ContainsKey(DiagnosticPropertyKeys.CollectionExpressionToImplicit))
+            {
+                return (ct => ConvertToImplicitAsync(document, collectionExpression, ct), UseImplicitlyTypedArrayTitle);
+            }
+            else
+            {
+                return (ct => ConvertToExplicitAsync(document, collectionExpression, ct), UseExplicitlyTypedArrayTitle);
+            }
+        }
+        else
         {
-            ImplicitArrayCreationExpressionSyntax implicitArrayCreation => await ChangeArrayTypeToExplicitAsync(document, implicitArrayCreation, cancellationToken).ConfigureAwait(false),
-            ArrayCreationExpressionSyntax arrayCreation => await ChangeArrayTypeToImplicitAsync(document, arrayCreation, cancellationToken).ConfigureAwait(false),
-            _ => throw new InvalidOperationException()
-        };
+            throw new InvalidOperationException();
+        }
     }
 
-    private static async Task<Document> ChangeArrayTypeToExplicitAsync(
+    private static async Task<Document> ConvertToExplicitAsync(
         Document document,
         ImplicitArrayCreationExpressionSyntax implicitArrayCreation,
         CancellationToken cancellationToken)
     {
         SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
-
         ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(implicitArrayCreation, cancellationToken);
-
         var arrayType = (ArrayTypeSyntax)typeSymbol.ToTypeSyntax().WithSimplifierAnnotation();
 
         SyntaxToken newKeyword = implicitArrayCreation.NewKeyword;
@@ -124,7 +156,24 @@ private static async Task<Document> ChangeArrayTypeToExplicitAsync(
         return await document.ReplaceNodeAsync(implicitArrayCreation, newNode, cancellationToken).ConfigureAwait(false);
     }
 
-    private static async Task<Document> ChangeArrayTypeToImplicitAsync(
+    private static async Task<Document> ConvertToExplicitAsync(
+        Document document,
+        CollectionExpressionSyntax collectionExpression,
+        CancellationToken cancellationToken)
+    {
+        SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+        ITypeSymbol typeSymbol = semanticModel.GetTypeInfo(collectionExpression, cancellationToken).ConvertedType;
+
+        ArrayCreationExpressionSyntax arrayCreation = ArrayCreationExpression(
+            Token(SyntaxKind.NewKeyword),
+            (ArrayTypeSyntax)typeSymbol.ToTypeSyntax().WithSimplifierAnnotation(),
+            ConvertCollectionExpressionToInitializer(collectionExpression, SyntaxKind.ArrayInitializerExpression))
+            .WithTriviaFrom(collectionExpression);
+
+        return await document.ReplaceNodeAsync(collectionExpression, arrayCreation, cancellationToken).ConfigureAwait(false);
+    }
+
+    private static async Task<Document> ConvertToImplicitAsync(
         Document document,
         ArrayCreationExpressionSyntax arrayCreation,
         CancellationToken cancellationToken)
@@ -159,4 +208,41 @@ private static async Task<Document> ChangeArrayTypeToImplicitAsync(
 
         return await document.ReplaceNodeAsync(arrayCreation, implicitArrayCreation, cancellationToken).ConfigureAwait(false);
     }
+
+    private static async Task<Document> ConvertToImplicitAsync(
+        Document document,
+        CollectionExpressionSyntax collectionExpression,
+        CancellationToken cancellationToken)
+    {
+        InitializerExpressionSyntax initializer = ConvertCollectionExpressionToInitializer(collectionExpression, SyntaxKind.ArrayInitializerExpression);
+
+        ImplicitArrayCreationExpressionSyntax implicitArrayCreation = ImplicitArrayCreationExpression(initializer)
+            .WithTriviaFrom(collectionExpression);
+
+        return await document.ReplaceNodeAsync(collectionExpression, implicitArrayCreation, cancellationToken).ConfigureAwait(false);
+    }
+
+    private static async Task<Document> ConvertToCollectionExpressionAsync(
+        Document document,
+        ArrayCreationExpressionSyntax arrayCreation,
+        CancellationToken cancellationToken)
+    {
+        CollectionExpressionSyntax collectionExpression = ConvertInitializerToCollectionExpression(arrayCreation.Initializer)
+            .WithTriviaFrom(arrayCreation)
+            .WithFormatterAnnotation();
+
+        return await document.ReplaceNodeAsync(arrayCreation, collectionExpression, cancellationToken).ConfigureAwait(false);
+    }
+
+    private static async Task<Document> ConvertToCollectionExpressionAsync(
+        Document document,
+        ImplicitArrayCreationExpressionSyntax implicitArrayCreation,
+        CancellationToken cancellationToken)
+    {
+        CollectionExpressionSyntax collectionExpression = ConvertInitializerToCollectionExpression(implicitArrayCreation.Initializer)
+            .WithTriviaFrom(implicitArrayCreation)
+            .WithFormatterAnnotation();
+
+        return await document.ReplaceNodeAsync(implicitArrayCreation, collectionExpression, cancellationToken).ConfigureAwait(false);
+    }
 }
diff --git a/src/Analyzers.CodeFixes/CSharp/CodeFixes/UseImplicitOrExplicitObjectCreationCodeFixProvider.cs b/src/Analyzers.CodeFixes/CSharp/CodeFixes/UseImplicitOrExplicitObjectCreationCodeFixProvider.cs
index 2236a0169c..5386cfc958 100644
--- a/src/Analyzers.CodeFixes/CSharp/CodeFixes/UseImplicitOrExplicitObjectCreationCodeFixProvider.cs
+++ b/src/Analyzers.CodeFixes/CSharp/CodeFixes/UseImplicitOrExplicitObjectCreationCodeFixProvider.cs
@@ -10,7 +10,9 @@
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Roslynator.CodeFixes;
+using Roslynator.CSharp.Analysis;
 using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
+using static Roslynator.CSharp.SyntaxRefactorings;
 
 namespace Roslynator.CSharp.CodeFixes;
 
@@ -18,6 +20,12 @@ namespace Roslynator.CSharp.CodeFixes;
 [Shared]
 public class UseImplicitOrExplicitObjectCreationCodeFixProvider : BaseCodeFixProvider
 {
+    private const string UseExplicitObjectCreationTitle = "Use explicit type";
+    private const string UseImplicitObjectCreationTitle = "Use implicit type";
+    private const string UseCollectionExpressionTitle = "Use collection expression";
+
+    private const string UseCollectionExpressionEquivalenceKey = "UseCollectionExpression";
+
     public sealed override ImmutableArray<string> FixableDiagnosticIds
     {
         get { return ImmutableArray.Create(DiagnosticIdentifiers.UseImplicitOrExplicitObjectCreation); }
@@ -31,7 +39,11 @@ public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
             root,
             context.Span,
             out SyntaxNode node,
-            predicate: f => f.IsKind(SyntaxKind.ObjectCreationExpression, SyntaxKind.ImplicitObjectCreationExpression, SyntaxKind.VariableDeclaration)))
+            predicate: f => f.IsKind(
+                SyntaxKind.ObjectCreationExpression,
+                SyntaxKind.ImplicitObjectCreationExpression,
+                SyntaxKind.CollectionExpression,
+                SyntaxKind.VariableDeclaration)))
         {
             return;
         }
@@ -41,14 +53,27 @@ public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
 
         if (node is ObjectCreationExpressionSyntax objectCreation)
         {
+            bool useCollectionExpression = diagnostic.Properties.ContainsKey(DiagnosticPropertyKeys.ExplicitToCollectionExpression);
+
             CodeAction codeAction = CodeAction.Create(
-                "Use implicit object creation",
+                (useCollectionExpression)
+                    ? UseCollectionExpressionTitle
+                    : UseImplicitObjectCreationTitle,
                 ct =>
                 {
-                    ImplicitObjectCreationExpressionSyntax implicitObjectCreation = ImplicitObjectCreationExpression(
-                        objectCreation.NewKeyword.WithTrailingTrivia(objectCreation.NewKeyword.TrailingTrivia.EmptyIfWhitespace()),
-                        objectCreation.ArgumentList ?? ArgumentList().WithTrailingTrivia(objectCreation.Type.GetTrailingTrivia()),
-                        objectCreation.Initializer);
+                    SyntaxNode newNode;
+
+                    if (useCollectionExpression)
+                    {
+                        newNode = ConvertInitializerToCollectionExpression(objectCreation.Initializer).WithFormatterAnnotation();
+                    }
+                    else
+                    {
+                        newNode = ImplicitObjectCreationExpression(
+                            objectCreation.NewKeyword.WithTrailingTrivia(objectCreation.NewKeyword.TrailingTrivia.EmptyIfWhitespace()),
+                            objectCreation.ArgumentList ?? ArgumentList().WithTrailingTrivia(objectCreation.Type.GetTrailingTrivia()),
+                            objectCreation.Initializer);
+                    }
 
                     if (objectCreation.IsParentKind(SyntaxKind.EqualsValueClause)
                         && objectCreation.Parent.IsParentKind(SyntaxKind.VariableDeclarator)
@@ -56,55 +81,130 @@ public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
                         && variableDeclaration.Type.IsVar)
                     {
                         VariableDeclarationSyntax newVariableDeclaration = variableDeclaration
-                            .ReplaceNode(objectCreation, implicitObjectCreation)
+                            .ReplaceNode(objectCreation, newNode)
                             .WithType(objectCreation.Type.WithTriviaFrom(variableDeclaration.Type));
 
                         return document.ReplaceNodeAsync(variableDeclaration, newVariableDeclaration, ct);
                     }
                     else
                     {
-                        return document.ReplaceNodeAsync(objectCreation, implicitObjectCreation, ct);
+                        return document.ReplaceNodeAsync(objectCreation, newNode, ct);
                     }
                 },
-                GetEquivalenceKey(diagnostic));
+                GetEquivalenceKey(diagnostic, (useCollectionExpression) ? UseCollectionExpressionEquivalenceKey : null));
 
             context.RegisterCodeFix(codeAction, diagnostic);
         }
         else if (node is ImplicitObjectCreationExpressionSyntax implicitObjectCreation)
         {
-            CodeAction codeAction = CodeAction.Create(
-                "Use explicit object creation",
-                async ct =>
-                {
-                    SemanticModel semanticModel = await context.Document.GetSemanticModelAsync(ct).ConfigureAwait(false);
+            if (diagnostic.Properties.ContainsKey(DiagnosticPropertyKeys.ImplicitToCollectionExpression))
+            {
+                CodeAction codeAction = CodeAction.Create(
+                    UseCollectionExpressionTitle,
+                    async ct =>
+                    {
+                        CollectionExpressionSyntax collectionExpression = ConvertInitializerToCollectionExpression(implicitObjectCreation.Initializer)
+                            .PrependToLeadingTrivia(implicitObjectCreation.NewKeyword.LeadingTrivia);
 
-                    ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(implicitObjectCreation, ct);
+                        if (implicitObjectCreation.Initializer is null)
+                            collectionExpression = collectionExpression.WithTrailingTrivia(implicitObjectCreation.ArgumentList.GetTrailingTrivia());
 
-                    TypeSyntax type = typeSymbol.ToTypeSyntax().WithSimplifierAnnotation();
+                        collectionExpression = collectionExpression.WithFormatterAnnotation();
 
-                    SyntaxToken newKeyword = implicitObjectCreation.NewKeyword;
+                        return await document.ReplaceNodeAsync(implicitObjectCreation, collectionExpression, ct).ConfigureAwait(false);
+                    },
+                    GetEquivalenceKey(diagnostic, UseCollectionExpressionEquivalenceKey));
 
-                    if (!newKeyword.TrailingTrivia.Any())
-                        newKeyword = newKeyword.WithTrailingTrivia(ElasticSpace);
+                context.RegisterCodeFix(codeAction, diagnostic);
+            }
+            else
+            {
+                CodeAction codeAction = CodeAction.Create(
+                    UseExplicitObjectCreationTitle,
+                    async ct =>
+                    {
+                        SemanticModel semanticModel = await context.Document.GetSemanticModelAsync(ct).ConfigureAwait(false);
+                        ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(implicitObjectCreation, ct);
+                        TypeSyntax type = typeSymbol.ToTypeSyntax().WithSimplifierAnnotation();
 
-                    ObjectCreationExpressionSyntax objectCreation = ObjectCreationExpression(
-                        newKeyword,
-                        type,
-                        implicitObjectCreation.ArgumentList,
-                        implicitObjectCreation.Initializer);
+                        SyntaxToken newKeyword = implicitObjectCreation.NewKeyword;
 
-                    return await document.ReplaceNodeAsync(implicitObjectCreation, objectCreation, ct).ConfigureAwait(false);
-                },
-                GetEquivalenceKey(diagnostic));
+                        if (!newKeyword.TrailingTrivia.Any())
+                            newKeyword = newKeyword.WithTrailingTrivia(ElasticSpace);
 
-            context.RegisterCodeFix(codeAction, diagnostic);
+                        ObjectCreationExpressionSyntax objectCreation = ObjectCreationExpression(
+                            newKeyword,
+                            type,
+                            implicitObjectCreation.ArgumentList,
+                            implicitObjectCreation.Initializer);
+
+                        return await document.ReplaceNodeAsync(implicitObjectCreation, objectCreation, ct).ConfigureAwait(false);
+                    },
+                    GetEquivalenceKey(diagnostic));
+
+                context.RegisterCodeFix(codeAction, diagnostic);
+            }
+        }
+        else if (node is CollectionExpressionSyntax collectionExpression)
+        {
+            if (diagnostic.Properties.ContainsKey(DiagnosticPropertyKeys.CollectionExpressionToImplicit))
+            {
+                CodeAction codeAction = CodeAction.Create(
+                    UseImplicitObjectCreationTitle,
+                    async ct =>
+                    {
+                        SemanticModel semanticModel = await context.Document.GetSemanticModelAsync(ct).ConfigureAwait(false);
+                        ITypeSymbol typeSymbol = semanticModel.GetTypeInfo(collectionExpression, ct).ConvertedType;
+
+                        ImplicitObjectCreationExpressionSyntax objectCreation = ImplicitObjectCreationExpression(
+                            Token(SyntaxKind.NewKeyword),
+                            ArgumentList(),
+                            ConvertCollectionExpressionToInitializer(
+                                collectionExpression,
+                                SyntaxKind.CollectionInitializerExpression))
+                            .WithTriviaFrom(collectionExpression);
+
+                        return await document.ReplaceNodeAsync(collectionExpression, objectCreation, ct).ConfigureAwait(false);
+                    },
+                    GetEquivalenceKey(diagnostic));
+
+                context.RegisterCodeFix(codeAction, diagnostic);
+            }
+            else
+            {
+                CodeAction codeAction = CodeAction.Create(
+                    UseExplicitObjectCreationTitle,
+                    async ct =>
+                    {
+                        SemanticModel semanticModel = await context.Document.GetSemanticModelAsync(ct).ConfigureAwait(false);
+                        ITypeSymbol typeSymbol = semanticModel.GetTypeInfo(collectionExpression, ct).ConvertedType;
+                        TypeSyntax type = typeSymbol.ToTypeSyntax().WithSimplifierAnnotation();
+
+                        ObjectCreationExpressionSyntax objectCreation = ObjectCreationExpression(
+                            Token(SyntaxKind.NewKeyword),
+                            type,
+                            ArgumentList(),
+                            ConvertCollectionExpressionToInitializer(
+                                collectionExpression,
+                                SyntaxKind.CollectionInitializerExpression));
+
+                        objectCreation = objectCreation
+                            .WithLeadingTrivia(collectionExpression.GetLeadingTrivia())
+                            .WithTrailingTrivia(collectionExpression.GetTrailingTrivia());
+
+                        return await document.ReplaceNodeAsync(collectionExpression, objectCreation, ct).ConfigureAwait(false);
+                    },
+                    GetEquivalenceKey(diagnostic));
+
+                context.RegisterCodeFix(codeAction, diagnostic);
+            }
         }
         else
         {
             var variableDeclaration = (VariableDeclarationSyntax)node;
 
             CodeAction codeAction = CodeAction.Create(
-                "Use explicit object creation",
+                UseExplicitObjectCreationTitle,
                 ct =>
                 {
                     var implicitObjectCreation = (ImplicitObjectCreationExpressionSyntax)variableDeclaration.Variables.Single().Initializer.Value;
diff --git a/src/Analyzers.CodeFixes/Roslynator.Analyzers.nuspec b/src/Analyzers.CodeFixes/Roslynator.Analyzers.nuspec
index 38a5cae875..ba5c9a1a83 100644
--- a/src/Analyzers.CodeFixes/Roslynator.Analyzers.nuspec
+++ b/src/Analyzers.CodeFixes/Roslynator.Analyzers.nuspec
@@ -11,7 +11,7 @@
     <requireLicenseAcceptance>false</requireLicenseAcceptance>
     <description>A collection of 200+ analyzers for C#, powered by Roslyn.
 
-  - This package is dependent on Microsoft.CodeAnalysis.CSharp.Workspaces 4.6.0.</description>
+  - This package is dependent on Microsoft.CodeAnalysis.CSharp.Workspaces 4.7.0.</description>
     <summary>A collection of 200+ analyzers for C#, powered by Roslyn.</summary>
     <copyright>Copyright (c) 2016-2023 Josef Pihrt</copyright>
     <tags>Roslyn Analyzer Refactoring Productivity CodeAnalysis C# CSharp</tags>
diff --git a/src/Analyzers.xml b/src/Analyzers.xml
index 5f30d9d116..d3b2e49c3e 100644
--- a/src/Analyzers.xml
+++ b/src/Analyzers.xml
@@ -1879,7 +1879,7 @@ foreach (var item in items)
     <Id>RCS1014</Id>
     <Identifier>UseExplicitlyOrImplicitlyTypedArray</Identifier>
     <Title>Use explicitly/implicitly typed array</Title>
-    <MessageFormat>Use {0} typed array</MessageFormat>
+    <MessageFormat>{0}</MessageFormat>
     <DefaultSeverity>Info</DefaultSeverity>
     <IsEnabledByDefault>false</IsEnabledByDefault>
     <Samples>
@@ -1890,6 +1890,7 @@ foreach (var item in items)
     </Samples>
     <ConfigOptions>
       <Option Key="array_creation_type_style" IsRequired="true" />
+      <Option Key="use_collection_expression" />
     </ConfigOptions>
     <Options>
       <Option Identifier="UseImplicitlyTypedArrayWhenTypeIsObvious">
@@ -7388,7 +7389,7 @@ void M()
     <Id>RCS1250</Id>
     <Identifier>UseImplicitOrExplicitObjectCreation</Identifier>
     <Title>Use implicit/explicit object creation</Title>
-    <MessageFormat>Use {0} object creation</MessageFormat>
+    <MessageFormat>{0}</MessageFormat>
     <DefaultSeverity>Info</DefaultSeverity>
     <IsEnabledByDefault>false</IsEnabledByDefault>
     <MinLanguageVersion>9.0</MinLanguageVersion>
@@ -7401,6 +7402,7 @@ void M()
     <ConfigOptions>
       <Option Key="object_creation_type_style" IsRequired="true" />
       <Option Key="use_var_instead_of_implicit_object_creation" />
+      <Option Key="use_collection_expression" />
     </ConfigOptions>
     <Links>
       <Link>
diff --git a/src/Analyzers/CSharp/Analysis/ObjectCreation/ImplicitOrExplicitCreationAnalysis.cs b/src/Analyzers/CSharp/Analysis/ObjectCreation/ImplicitOrExplicitCreationAnalysis.cs
new file mode 100644
index 0000000000..2551acb951
--- /dev/null
+++ b/src/Analyzers/CSharp/Analysis/ObjectCreation/ImplicitOrExplicitCreationAnalysis.cs
@@ -0,0 +1,658 @@
+// Copyright (c) .NET Foundation and Contributors. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Diagnostics;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Roslynator.CSharp.CodeStyle;
+
+namespace Roslynator.CSharp.Analysis;
+
+internal abstract class ImplicitOrExplicitCreationAnalysis
+{
+    protected static readonly ImmutableDictionary<string, string> _implicitToCollectionExpression = ImmutableDictionary.CreateRange(new[]
+        {
+            new KeyValuePair<string, string>(DiagnosticPropertyKeys.ImplicitToCollectionExpression, null)
+        });
+
+    protected static readonly ImmutableDictionary<string, string> _collectionExpressionToImplicit = ImmutableDictionary.CreateRange(new[]
+        {
+            new KeyValuePair<string, string>(DiagnosticPropertyKeys.CollectionExpressionToImplicit, null)
+        });
+
+    protected static readonly ImmutableDictionary<string, string> _explicitToCollectionExpression = ImmutableDictionary.CreateRange(new[]
+        {
+            new KeyValuePair<string, string>(DiagnosticPropertyKeys.ExplicitToCollectionExpression, null)
+        });
+
+    public abstract TypeStyle GetTypeStyle(ref SyntaxNodeAnalysisContext context);
+
+    protected abstract void ReportExplicitToImplicit(ref SyntaxNodeAnalysisContext context);
+
+    protected abstract void ReportExplicitToCollectionExpression(ref SyntaxNodeAnalysisContext context);
+
+    protected abstract void ReportImplicitToExplicit(ref SyntaxNodeAnalysisContext context);
+
+    protected abstract void ReportImplicitToCollectionExpression(ref SyntaxNodeAnalysisContext context);
+
+    protected abstract void ReportCollectionExpressionToImplicit(ref SyntaxNodeAnalysisContext context);
+
+    protected virtual bool IsInitializerObvious(ref SyntaxNodeAnalysisContext context) => false;
+
+    public virtual void AnalyzeExplicitCreation(ref SyntaxNodeAnalysisContext context)
+    {
+        if (context.Node.ContainsDiagnostics)
+            return;
+
+        TypeStyle style = GetTypeStyle(ref context);
+
+        if (style != TypeStyle.Implicit
+            && style != TypeStyle.ImplicitWhenTypeIsObvious)
+        {
+            return;
+        }
+
+        var expression = (ExpressionSyntax)context.Node;
+
+        SyntaxNode parent = expression.Parent;
+
+        switch (parent.Kind())
+        {
+            case SyntaxKind.ThrowExpression:
+            case SyntaxKind.ThrowStatement:
+                {
+                    if (context.SemanticModel
+                        .GetTypeSymbol(expression, context.CancellationToken)?
+                        .HasMetadataName(MetadataNames.System_Exception) == true)
+                    {
+                        ReportExplicitToImplicit(ref context);
+                    }
+
+                    break;
+                }
+            case SyntaxKind.EqualsValueClause:
+                {
+                    parent = parent.Parent;
+
+                    SyntaxDebug.Assert(parent.IsKind(SyntaxKind.VariableDeclarator, SyntaxKind.PropertyDeclaration), parent);
+
+                    if (parent.IsKind(SyntaxKind.VariableDeclarator))
+                    {
+                        parent = parent.Parent;
+
+                        if (parent is VariableDeclarationSyntax variableDeclaration)
+                        {
+                            SyntaxDebug.Assert(variableDeclaration.IsParentKind(SyntaxKind.FieldDeclaration, SyntaxKind.LocalDeclarationStatement, SyntaxKind.UsingStatement), variableDeclaration.Parent);
+
+                            if (variableDeclaration.IsParentKind(SyntaxKind.FieldDeclaration))
+                            {
+                                AnalyzeType(ref context, expression, variableDeclaration.Type);
+                            }
+                            else if (variableDeclaration.IsParentKind(SyntaxKind.LocalDeclarationStatement, SyntaxKind.UsingStatement))
+                            {
+                                if (context.UseVarInsteadOfImplicitObjectCreation() == false)
+                                {
+                                    if (variableDeclaration.Type.IsVar)
+                                    {
+                                        ReportExplicitToImplicit(ref context);
+                                    }
+                                    else
+                                    {
+                                        AnalyzeType(ref context, expression, variableDeclaration.Type);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    else if (parent.IsKind(SyntaxKind.PropertyDeclaration))
+                    {
+                        AnalyzeType(ref context, expression, ((PropertyDeclarationSyntax)parent).Type);
+                    }
+
+                    break;
+                }
+            case SyntaxKind.ArrowExpressionClause:
+                {
+                    TypeSyntax type = DetermineReturnType(parent.Parent);
+
+                    SyntaxDebug.Assert(type is not null, parent);
+
+                    if (type is not null)
+                        AnalyzeType(ref context, expression, type);
+
+                    break;
+                }
+            case SyntaxKind.ArrayInitializerExpression:
+                {
+                    SyntaxDebug.Assert(parent.IsParentKind(SyntaxKind.ArrayCreationExpression, SyntaxKind.ImplicitArrayCreationExpression, SyntaxKind.EqualsValueClause, SyntaxKind.ImplicitStackAllocArrayCreationExpression), parent.Parent);
+
+                    if (parent.IsParentKind(SyntaxKind.ArrayCreationExpression))
+                    {
+                        var arrayCreationExpression = (ArrayCreationExpressionSyntax)parent.Parent;
+
+                        AnalyzeType(ref context, expression, arrayCreationExpression.Type.ElementType);
+                    }
+                    else if (parent.IsParentKind(SyntaxKind.EqualsValueClause))
+                    {
+                        parent = parent.Parent.Parent;
+
+                        if (parent.IsKind(SyntaxKind.VariableDeclarator))
+                        {
+                            parent = parent.Parent;
+
+                            if (parent is VariableDeclarationSyntax variableDeclaration)
+                            {
+                                if (parent.IsParentKind(SyntaxKind.FieldDeclaration))
+                                {
+                                    AnalyzeArrayType(ref context, expression, variableDeclaration.Type);
+                                }
+                                else if (parent.IsParentKind(SyntaxKind.LocalDeclarationStatement, SyntaxKind.UsingStatement))
+                                {
+                                    if (!variableDeclaration.Type.IsVar)
+                                        AnalyzeArrayType(ref context, expression, variableDeclaration.Type);
+                                }
+                            }
+                        }
+                        else if (parent.IsKind(SyntaxKind.PropertyDeclaration))
+                        {
+                            AnalyzeArrayType(ref context, expression, ((PropertyDeclarationSyntax)parent).Type);
+                        }
+                    }
+
+                    break;
+                }
+            case SyntaxKind.ReturnStatement:
+            case SyntaxKind.YieldReturnStatement:
+                {
+                    if (style != TypeStyle.Implicit
+                        && !IsSingleReturnStatement(parent))
+                    {
+                        return;
+                    }
+
+                    for (SyntaxNode node = parent.Parent; node is not null; node = node.Parent)
+                    {
+                        if (CSharpFacts.IsAnonymousFunctionExpression(node.Kind()))
+                            return;
+
+                        TypeSyntax type = DetermineReturnType(node);
+
+                        if (type is not null)
+                        {
+                            if (parent.IsKind(SyntaxKind.YieldReturnStatement))
+                            {
+                                ITypeSymbol typeSymbol = context.SemanticModel.GetTypeSymbol(type, context.CancellationToken);
+
+                                if (typeSymbol?.OriginalDefinition.SpecialType == SpecialType.System_Collections_Generic_IEnumerable_T)
+                                {
+                                    var ienumerableOfT = (INamedTypeSymbol)typeSymbol;
+
+                                    ITypeSymbol typeSymbol2 = ienumerableOfT.TypeArguments.Single();
+
+                                    AnalyzeTypeSymbol(ref context, expression, typeSymbol2);
+                                }
+                            }
+                            else
+                            {
+                                AnalyzeType(ref context, expression, type);
+                            }
+
+                            return;
+                        }
+                    }
+
+                    break;
+                }
+            case SyntaxKind.SimpleAssignmentExpression:
+            case SyntaxKind.CoalesceAssignmentExpression:
+            case SyntaxKind.AddAssignmentExpression:
+            case SyntaxKind.SubtractAssignmentExpression:
+                {
+                    if (style == TypeStyle.Implicit)
+                    {
+                        var assignment = (AssignmentExpressionSyntax)parent;
+                        AnalyzeExpression(ref context, expression, assignment.Left);
+                    }
+
+                    break;
+                }
+            case SyntaxKind.CoalesceExpression:
+                {
+                    if (style == TypeStyle.Implicit)
+                    {
+                        var coalesceExpression = (BinaryExpressionSyntax)parent;
+                        AnalyzeExpression(ref context, expression, coalesceExpression.Left);
+                    }
+                    else if (style == TypeStyle.ImplicitWhenTypeIsObvious
+                        && parent.IsParentKind(SyntaxKind.EqualsValueClause))
+                    {
+                        if (parent.Parent.Parent is VariableDeclaratorSyntax variableDeclarator)
+                        {
+                            if (variableDeclarator.Parent is VariableDeclarationSyntax variableDeclaration
+                                && variableDeclaration.IsParentKind(SyntaxKind.FieldDeclaration))
+                            {
+                                AnalyzeType(ref context, expression, variableDeclaration.Type);
+                            }
+                        }
+                        else if (parent.Parent.Parent is PropertyDeclarationSyntax propertyDeclaration)
+                        {
+                            AnalyzeType(ref context, expression, propertyDeclaration.Type);
+                        }
+                    }
+
+                    break;
+                }
+            case SyntaxKind.CollectionInitializerExpression:
+                {
+                    SyntaxDebug.Assert(parent.IsParentKind(SyntaxKind.ObjectCreationExpression, SyntaxKind.ImplicitObjectCreationExpression, SyntaxKind.SimpleAssignmentExpression), parent.Parent);
+
+                    parent = parent.Parent;
+                    if (parent.IsKind(SyntaxKind.ObjectCreationExpression, SyntaxKind.ImplicitObjectCreationExpression))
+                    {
+                        SyntaxNode parentObjectCreation = parent;
+
+                        parent = parent.Parent;
+                        if (parent.IsKind(SyntaxKind.EqualsValueClause))
+                        {
+                            parent = parent.Parent;
+                            if (parent.IsKind(SyntaxKind.VariableDeclarator))
+                            {
+                                parent = parent.Parent;
+                                if (parent is VariableDeclarationSyntax variableDeclaration
+                                    && parent.IsParentKind(SyntaxKind.FieldDeclaration, SyntaxKind.LocalDeclarationStatement))
+                                {
+                                    if (parentObjectCreation is ExpressionSyntax parentObjectCreationExpression)
+                                    {
+                                        AnalyzeExpression(ref context, expression, parentObjectCreationExpression, extractGenericType: true);
+                                    }
+                                    else
+                                    {
+                                        AnalyzeType(ref context, expression, variableDeclaration.Type, extractGenericType: true);
+                                    }
+                                }
+                            }
+                            else if (parent.IsKind(SyntaxKind.PropertyDeclaration))
+                            {
+                                AnalyzeType(ref context, expression, ((PropertyDeclarationSyntax)parent).Type);
+                            }
+                        }
+                    }
+
+                    break;
+                }
+        }
+    }
+
+    public virtual void AnalyzeImplicitCreation(ref SyntaxNodeAnalysisContext context)
+    {
+        AnalyzeImplicit(ref context);
+    }
+
+    public virtual void AnalyzeCollectionExpression(ref SyntaxNodeAnalysisContext context)
+    {
+        AnalyzeImplicit(ref context);
+    }
+
+    private void AnalyzeImplicit(ref SyntaxNodeAnalysisContext context)
+    {
+        if (context.Node.ContainsDiagnostics)
+            return;
+
+        TypeStyle style = GetTypeStyle(ref context);
+
+        SyntaxNode parent = context.Node.Parent;
+
+        switch (parent.Kind())
+        {
+            case SyntaxKind.ThrowExpression:
+            case SyntaxKind.ThrowStatement:
+                {
+                    if (style == TypeStyle.Explicit
+                        && context.SemanticModel.GetTypeSymbol(context.Node, context.CancellationToken)?
+                            .HasMetadataName(MetadataNames.System_Exception) == true)
+                    {
+                        ReportImplicitToExplicit(ref context);
+                    }
+
+                    break;
+                }
+            case SyntaxKind.EqualsValueClause:
+                {
+                    parent = parent.Parent;
+
+                    SyntaxDebug.Assert(parent.IsKind(SyntaxKind.VariableDeclarator, SyntaxKind.PropertyDeclaration, SyntaxKind.Parameter), parent);
+
+                    if (parent.IsKind(SyntaxKind.VariableDeclarator))
+                    {
+                        parent = parent.Parent;
+
+                        if (parent is VariableDeclarationSyntax variableDeclaration)
+                        {
+                            bool isVar = variableDeclaration.Type.IsVar;
+
+                            SyntaxDebug.Assert(!isVar || context.Node.IsKind(SyntaxKind.CollectionExpression, SyntaxKind.ImplicitArrayCreationExpression), variableDeclaration);
+                            SyntaxDebug.Assert(parent.IsParentKind(SyntaxKind.FieldDeclaration, SyntaxKind.LocalDeclarationStatement, SyntaxKind.UsingStatement), parent.Parent);
+
+                            if (!AnalyzeImplicit(ref context, isObvious: !isVar, allowCollectionExpression: !isVar)
+                                && parent.IsParentKind(SyntaxKind.LocalDeclarationStatement, SyntaxKind.UsingStatement)
+                                && variableDeclaration.Variables.Count == 1
+                                && !isVar
+                                && context.UseVarInsteadOfImplicitObjectCreation() == true)
+                            {
+                                DiagnosticHelpers.ReportDiagnostic(context, DiagnosticRules.UseImplicitOrExplicitObjectCreation, variableDeclaration, "explicit");
+                            }
+                        }
+                    }
+                    else if (parent.IsKind(SyntaxKind.PropertyDeclaration))
+                    {
+                        AnalyzeImplicitObvious(ref context);
+                    }
+
+                    break;
+                }
+            case SyntaxKind.ArrowExpressionClause:
+                {
+                    if (style == TypeStyle.Explicit)
+                    {
+                        TypeSyntax type = DetermineReturnType(parent.Parent);
+
+                        SyntaxDebug.Assert(type is not null, parent);
+
+                        if (type is not null)
+                            AnalyzeImplicitObvious(ref context);
+                    }
+
+                    break;
+                }
+            case SyntaxKind.ArrayInitializerExpression:
+                {
+                    SyntaxDebug.Assert(parent.IsParentKind(SyntaxKind.ArrayCreationExpression, SyntaxKind.ImplicitArrayCreationExpression, SyntaxKind.EqualsValueClause), parent.Parent);
+
+                    if (parent.IsParentKind(SyntaxKind.ArrayCreationExpression))
+                        AnalyzeImplicitObvious(ref context);
+
+                    break;
+                }
+            case SyntaxKind.ReturnStatement:
+            case SyntaxKind.YieldReturnStatement:
+                {
+                    if (style != TypeStyle.Explicit
+                        && (style != TypeStyle.ImplicitWhenTypeIsObvious || IsSingleReturnStatement(parent)))
+                    {
+                        return;
+                    }
+
+                    for (SyntaxNode node = parent.Parent; node is not null; node = node.Parent)
+                    {
+                        if (CSharpFacts.IsAnonymousFunctionExpression(node.Kind()))
+                            return;
+
+                        TypeSyntax type = DetermineReturnType(node);
+
+                        if (type is not null)
+                        {
+                            if (parent.IsKind(SyntaxKind.YieldReturnStatement))
+                            {
+                                ITypeSymbol typeSymbol = context.SemanticModel.GetTypeSymbol(type, context.CancellationToken);
+
+                                if (typeSymbol?.OriginalDefinition.SpecialType == SpecialType.System_Collections_Generic_IEnumerable_T)
+                                    AnalyzeImplicitNotObvious(ref context);
+                            }
+                            else
+                            {
+                                AnalyzeImplicit(ref context, isObvious: IsSingleReturnStatement(parent));
+                            }
+                        }
+                    }
+
+                    break;
+                }
+            case SyntaxKind.SimpleAssignmentExpression:
+            case SyntaxKind.CoalesceAssignmentExpression:
+            case SyntaxKind.AddAssignmentExpression:
+            case SyntaxKind.SubtractAssignmentExpression:
+                {
+                    AnalyzeImplicitNotObvious(ref context);
+                    break;
+                }
+            case SyntaxKind.CoalesceExpression:
+                {
+                    if (parent.IsParentKind(SyntaxKind.EqualsValueClause))
+                    {
+                        switch (parent.Parent.Parent)
+                        {
+                            case VariableDeclaratorSyntax variableDeclarator:
+                                {
+                                    if (variableDeclarator.Parent is VariableDeclarationSyntax variableDeclaration)
+                                        AnalyzeImplicit(ref context, isObvious: !variableDeclaration.Type.IsVar);
+
+                                    return;
+                                }
+                            case PropertyDeclarationSyntax:
+                                {
+                                    AnalyzeImplicitObvious(ref context);
+                                    return;
+                                }
+                        }
+                    }
+
+                    AnalyzeImplicitNotObvious(ref context);
+                    break;
+                }
+            case SyntaxKind.CollectionInitializerExpression:
+                {
+                    SyntaxDebug.Assert(parent.IsParentKind(SyntaxKind.ObjectCreationExpression, SyntaxKind.ImplicitObjectCreationExpression, SyntaxKind.SimpleAssignmentExpression), parent.Parent);
+
+                    if (style != TypeStyle.Explicit)
+                        return;
+
+                    parent = parent.Parent;
+                    if (parent.IsKind(SyntaxKind.ObjectCreationExpression, SyntaxKind.ImplicitObjectCreationExpression))
+                    {
+                        parent = parent.Parent;
+                        if (parent.IsKind(SyntaxKind.EqualsValueClause))
+                        {
+                            parent = parent.Parent;
+                            if (parent.IsKind(SyntaxKind.VariableDeclarator))
+                            {
+                                parent = parent.Parent;
+                                if (parent is VariableDeclarationSyntax)
+                                {
+                                    SyntaxDebug.Assert(parent.IsParentKind(SyntaxKind.FieldDeclaration, SyntaxKind.LocalDeclarationStatement, SyntaxKind.UsingStatement), parent.Parent);
+
+                                    AnalyzeImplicitObvious(ref context);
+                                }
+                            }
+                            else if (parent.IsKind(SyntaxKind.PropertyDeclaration))
+                            {
+                                AnalyzeImplicitObvious(ref context);
+                            }
+                        }
+                    }
+
+                    break;
+                }
+        }
+    }
+
+    private void AnalyzeType(
+        ref SyntaxNodeAnalysisContext context,
+        ExpressionSyntax creationExpression,
+        TypeSyntax type,
+        bool extractGenericType = false)
+    {
+        if (!type.IsVar)
+            AnalyzeExpression(ref context, creationExpression, type, extractGenericType: extractGenericType);
+    }
+
+    private void AnalyzeArrayType(
+        ref SyntaxNodeAnalysisContext context,
+        ExpressionSyntax creationExpression,
+        TypeSyntax type)
+    {
+        if (type is ArrayTypeSyntax arrayType)
+        {
+            type = arrayType.ElementType;
+
+            if (!type.IsVar)
+                AnalyzeExpression(ref context, creationExpression, type);
+        }
+    }
+
+    private void AnalyzeExpression(
+        ref SyntaxNodeAnalysisContext context,
+        ExpressionSyntax creationExpression,
+        ExpressionSyntax expression,
+        bool extractGenericType = false)
+    {
+        ITypeSymbol typeSymbol1 = context.SemanticModel.GetTypeSymbol(expression, context.CancellationToken);
+
+        if (extractGenericType)
+        {
+            typeSymbol1 = (typeSymbol1 as INamedTypeSymbol)?.TypeArguments.SingleOrDefault(shouldThrow: false);
+        }
+
+        AnalyzeTypeSymbol(ref context, creationExpression, typeSymbol1);
+    }
+
+    private void AnalyzeTypeSymbol(
+        ref SyntaxNodeAnalysisContext context,
+        ExpressionSyntax creationExpression,
+        ITypeSymbol typeSymbol1)
+    {
+        if (typeSymbol1?.IsErrorType() == false)
+        {
+            ITypeSymbol typeSymbol2 = context.SemanticModel.GetTypeSymbol(creationExpression, context.CancellationToken);
+
+            if (SymbolEqualityComparer.Default.Equals(typeSymbol1, typeSymbol2))
+            {
+                if (((ObjectCreationExpressionSyntax)context.Node).ArgumentList?.Arguments.Any() != true
+                    && UseCollectionExpression(ref context))
+                {
+                    ReportExplicitToCollectionExpression(ref context);
+                }
+                else
+                {
+                    ReportExplicitToImplicit(ref context);
+                }
+            }
+        }
+    }
+
+    protected static TypeSyntax DetermineReturnType(SyntaxNode node)
+    {
+        switch (node.Kind())
+        {
+            case SyntaxKind.LocalFunctionStatement:
+                return ((LocalFunctionStatementSyntax)node).ReturnType;
+            case SyntaxKind.MethodDeclaration:
+                return ((MethodDeclarationSyntax)node).ReturnType;
+            case SyntaxKind.OperatorDeclaration:
+                return ((OperatorDeclarationSyntax)node).ReturnType;
+            case SyntaxKind.ConversionOperatorDeclaration:
+                return ((ConversionOperatorDeclarationSyntax)node).Type;
+            case SyntaxKind.PropertyDeclaration:
+                return ((PropertyDeclarationSyntax)node).Type;
+            case SyntaxKind.IndexerDeclaration:
+                return ((IndexerDeclarationSyntax)node).Type;
+        }
+
+        if (node is AccessorDeclarationSyntax)
+        {
+            SyntaxDebug.Assert(node.IsParentKind(SyntaxKind.AccessorList), node.Parent);
+
+            if (node.IsParentKind(SyntaxKind.AccessorList))
+                return DetermineReturnType(node.Parent.Parent);
+        }
+
+        return null;
+    }
+
+    private bool AnalyzeImplicitObvious(ref SyntaxNodeAnalysisContext context)
+    {
+        return AnalyzeImplicit(ref context, isObvious: true);
+    }
+
+    private bool AnalyzeImplicitNotObvious(ref SyntaxNodeAnalysisContext context)
+    {
+        return AnalyzeImplicit(ref context, isObvious: false);
+    }
+
+    private bool AnalyzeImplicit(ref SyntaxNodeAnalysisContext context, bool isObvious, bool allowCollectionExpression = true)
+    {
+        TypeStyle style = GetTypeStyle(ref context);
+
+        if (style == TypeStyle.Explicit)
+        {
+            ReportImplicitToExplicit(ref context);
+            return true;
+        }
+
+        if (style == TypeStyle.Implicit)
+        {
+            if (context.Node.IsKind(SyntaxKind.CollectionExpression))
+            {
+                if (context.UseCollectionExpression() == false)
+                {
+                    ReportCollectionExpressionToImplicit(ref context);
+                    return true;
+                }
+            }
+            else if (allowCollectionExpression
+                && UseCollectionExpressionFromImplicit(ref context))
+            {
+                ReportImplicitToCollectionExpression(ref context);
+                return true;
+            }
+        }
+        else if (style == TypeStyle.ImplicitWhenTypeIsObvious)
+        {
+            if (!isObvious
+                && !IsInitializerObvious(ref context))
+            {
+                ReportImplicitToExplicit(ref context);
+                return true;
+            }
+
+            if (context.Node.IsKind(SyntaxKind.CollectionExpression))
+            {
+                if (context.UseCollectionExpression() == false)
+                {
+                    ReportCollectionExpressionToImplicit(ref context);
+                    return true;
+                }
+            }
+            else if (allowCollectionExpression
+                && UseCollectionExpressionFromImplicit(ref context))
+            {
+                ReportImplicitToCollectionExpression(ref context);
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    protected abstract bool UseCollectionExpressionFromImplicit(ref SyntaxNodeAnalysisContext context);
+
+    protected static bool IsSingleReturnStatement(SyntaxNode parent)
+    {
+        return parent.IsKind(SyntaxKind.ReturnStatement)
+            && parent.Parent is BlockSyntax block
+            && block.Statements.Count == 1
+            && parent.Parent.Parent is MemberDeclarationSyntax;
+    }
+
+    protected static bool UseCollectionExpression(ref SyntaxNodeAnalysisContext context)
+    {
+        Debug.Assert(!context.Node.IsKind(SyntaxKind.CollectionExpression), context.Node.Kind().ToString());
+
+        return context.UseCollectionExpression() == true
+            && ((CSharpCompilation)context.Compilation).SupportsCollectionExpression()
+            && SyntaxUtility.CanConvertToCollectionExpression(context.Node, context.SemanticModel, context.CancellationToken);
+    }
+}
diff --git a/src/Analyzers/CSharp/Analysis/ObjectCreation/ImplicitOrExpressionArrayCreationAnalysis.cs b/src/Analyzers/CSharp/Analysis/ObjectCreation/ImplicitOrExpressionArrayCreationAnalysis.cs
new file mode 100644
index 0000000000..4cdbb4c77f
--- /dev/null
+++ b/src/Analyzers/CSharp/Analysis/ObjectCreation/ImplicitOrExpressionArrayCreationAnalysis.cs
@@ -0,0 +1,396 @@
+// Copyright (c) .NET Foundation and Contributors. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Text;
+using Roslynator.CSharp.CodeStyle;
+
+namespace Roslynator.CSharp.Analysis;
+
+internal class ImplicitOrExpressionArrayCreationAnalysis : ImplicitOrExplicitCreationAnalysis
+{
+    public static ImplicitOrExpressionArrayCreationAnalysis Instance { get; } = new();
+
+    public override void AnalyzeExplicitCreation(ref SyntaxNodeAnalysisContext context)
+    {
+        if (context.Node.ContainsDiagnostics)
+            return;
+
+        TypeStyle style = GetTypeStyle(ref context);
+
+        if (style != TypeStyle.Implicit
+            && style != TypeStyle.ImplicitWhenTypeIsObvious)
+        {
+            return;
+        }
+
+        var arrayCreation = (ArrayCreationExpressionSyntax)context.Node;
+
+        ArrayTypeSyntax arrayType = arrayCreation.Type;
+
+        if (arrayType.ContainsDirectives)
+            return;
+
+        SeparatedSyntaxList<ExpressionSyntax> expressions = arrayCreation.Initializer?.Expressions ?? default;
+
+        if (!expressions.Any())
+            return;
+
+        SyntaxNode parent = arrayCreation.Parent;
+
+        switch (parent.Kind())
+        {
+            case SyntaxKind.EqualsValueClause:
+                {
+                    parent = parent.Parent;
+
+                    SyntaxDebug.Assert(parent.IsKind(SyntaxKind.VariableDeclarator, SyntaxKind.PropertyDeclaration), parent);
+
+                    if (parent.IsKind(SyntaxKind.VariableDeclarator))
+                    {
+                        parent = parent.Parent;
+
+                        if (parent is VariableDeclarationSyntax variableDeclaration)
+                        {
+                            SyntaxDebug.Assert(variableDeclaration.IsParentKind(SyntaxKind.FieldDeclaration, SyntaxKind.LocalDeclarationStatement, SyntaxKind.UsingStatement), variableDeclaration.Parent);
+
+                            if (variableDeclaration.IsParentKind(SyntaxKind.FieldDeclaration))
+                            {
+                                AnalyzeExplicitObvious(ref context);
+                            }
+                            else if (variableDeclaration.IsParentKind(SyntaxKind.LocalDeclarationStatement, SyntaxKind.UsingStatement))
+                            {
+                                if (context.UseVarInsteadOfImplicitObjectCreation() != true)
+                                {
+                                    bool isVar = variableDeclaration.Type.IsVar;
+                                    AnalyzeExplicit(ref context, isObvious: !isVar, allowCollectionExpression: !isVar);
+                                }
+                            }
+                        }
+                    }
+                    else if (parent.IsKind(SyntaxKind.PropertyDeclaration))
+                    {
+                        AnalyzeExplicitObvious(ref context);
+                    }
+
+                    break;
+                }
+            case SyntaxKind.ArrowExpressionClause:
+                {
+                    TypeSyntax type = DetermineReturnType(parent.Parent);
+
+                    if (type is not null)
+                        AnalyzeExplicitObvious(ref context);
+
+                    break;
+                }
+            case SyntaxKind.ReturnStatement:
+                {
+                    if (style == TypeStyle.Implicit
+                        || IsSingleReturnStatement(parent))
+                    {
+                        for (SyntaxNode node = parent.Parent; node is not null; node = node.Parent)
+                        {
+                            if (CSharpFacts.IsAnonymousFunctionExpression(node.Kind()))
+                                return;
+
+                            TypeSyntax type = DetermineReturnType(node);
+
+                            if (type is not null)
+                            {
+                                AnalyzeExplicit(ref context, isObvious: IsSingleReturnStatement(parent));
+                                return;
+                            }
+                        }
+                    }
+
+                    break;
+                }
+            case SyntaxKind.SimpleAssignmentExpression:
+            case SyntaxKind.CoalesceAssignmentExpression:
+            case SyntaxKind.AddAssignmentExpression:
+            case SyntaxKind.SubtractAssignmentExpression:
+                {
+                    AnalyzeExplicitNotObvious(ref context);
+                    break;
+                }
+            case SyntaxKind.CoalesceExpression:
+                {
+                    if (style == TypeStyle.Implicit)
+                    {
+                        AnalyzeExplicitNotObvious(ref context);
+                    }
+                    else if (style == TypeStyle.ImplicitWhenTypeIsObvious
+                        && parent.IsParentKind(SyntaxKind.EqualsValueClause))
+                    {
+                        if (parent.Parent.Parent is VariableDeclaratorSyntax variableDeclarator)
+                        {
+                            if (variableDeclarator.Parent is VariableDeclarationSyntax variableDeclaration
+                                && variableDeclaration.IsParentKind(SyntaxKind.FieldDeclaration))
+                            {
+                                AnalyzeExplicitObvious(ref context);
+                            }
+                        }
+                        else if (parent.Parent.Parent is PropertyDeclarationSyntax)
+                        {
+                            AnalyzeExplicitObvious(ref context);
+                        }
+                    }
+
+                    break;
+                }
+        }
+    }
+
+    private void AnalyzeExplicitObvious(ref SyntaxNodeAnalysisContext context, bool allowCollectionExpression = true)
+    {
+        AnalyzeExplicit(ref context, isObvious: true, allowCollectionExpression: allowCollectionExpression);
+    }
+
+    private void AnalyzeExplicitNotObvious(ref SyntaxNodeAnalysisContext context, bool allowCollectionExpression = true)
+    {
+        AnalyzeExplicit(ref context, isObvious: false, allowCollectionExpression: allowCollectionExpression);
+    }
+
+    private bool AnalyzeExplicit(ref SyntaxNodeAnalysisContext context, bool isObvious, bool allowCollectionExpression = true)
+    {
+        TypeStyle style = GetTypeStyle(ref context);
+
+        if (style == TypeStyle.Implicit)
+        {
+            if (allowCollectionExpression
+                && UseCollectionExpression(ref context))
+            {
+                ReportExplicitToCollectionExpression(ref context);
+                return true;
+            }
+            else
+            {
+                ReportExplicitToImplicit(ref context);
+                return true;
+            }
+        }
+        else if (style == TypeStyle.ImplicitWhenTypeIsObvious)
+        {
+            if (isObvious
+                && allowCollectionExpression
+                && UseCollectionExpression(ref context))
+            {
+                ReportExplicitToCollectionExpression(ref context);
+                return true;
+            }
+            else if (isObvious
+                || IsInitializerObvious(ref context))
+            {
+                ReportExplicitToImplicit(ref context);
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public override void AnalyzeImplicitCreation(ref SyntaxNodeAnalysisContext context)
+    {
+        var implicitArrayCreation = (ImplicitArrayCreationExpressionSyntax)context.Node;
+
+        if (implicitArrayCreation.ContainsDiagnostics
+            || implicitArrayCreation.NewKeyword.ContainsDirectives
+            || implicitArrayCreation.OpenBracketToken.ContainsDirectives
+            || implicitArrayCreation.CloseBracketToken.ContainsDirectives)
+        {
+            return;
+        }
+
+        if (GetTypeStyle(ref context) == TypeStyle.Explicit)
+        {
+            var arrayTypeSymbol = context.SemanticModel.GetTypeSymbol(implicitArrayCreation, context.CancellationToken) as IArrayTypeSymbol;
+
+            if ((arrayTypeSymbol?.ElementType.SupportsExplicitDeclaration()) == true)
+                ReportImplicitToExplicit(ref context);
+
+            return;
+        }
+
+        base.AnalyzeImplicitCreation(ref context);
+    }
+
+    protected override bool IsInitializerObvious(ref SyntaxNodeAnalysisContext context)
+    {
+        if (context.Node is ArrayCreationExpressionSyntax arrayCreation)
+            return IsInitializerObvious(ref context, arrayCreation, arrayCreation.Initializer);
+
+        if (context.Node is ImplicitArrayCreationExpressionSyntax implicitArrayCreation)
+            return IsInitializerObvious(ref context, implicitArrayCreation, implicitArrayCreation.Initializer);
+
+        if (context.Node is CollectionExpressionSyntax collectionExpression)
+            return IsInitializerObvious(ref context, collectionExpression);
+
+        return false;
+    }
+
+    private static bool IsInitializerObvious(
+        ref SyntaxNodeAnalysisContext context,
+        ExpressionSyntax creationExpression,
+        InitializerExpressionSyntax initializer)
+    {
+        if (initializer is not null)
+        {
+            IArrayTypeSymbol arrayTypeSymbol = null;
+            var isObvious = false;
+
+            foreach (ExpressionSyntax expression in initializer.Expressions)
+            {
+                if (arrayTypeSymbol is null)
+                {
+                    arrayTypeSymbol = context.SemanticModel.GetTypeSymbol(creationExpression, context.CancellationToken) as IArrayTypeSymbol;
+
+                    if (arrayTypeSymbol?.ElementType.SupportsExplicitDeclaration() != true)
+                        return true;
+                }
+
+                isObvious = CSharpTypeAnalysis.IsTypeObvious(expression, arrayTypeSymbol.ElementType, includeNullability: true, context.SemanticModel, context.CancellationToken);
+
+                if (!isObvious)
+                    return false;
+            }
+
+            return isObvious;
+        }
+
+        return false;
+    }
+
+    private static bool IsInitializerObvious(ref SyntaxNodeAnalysisContext context, CollectionExpressionSyntax collectionExpression)
+    {
+        SeparatedSyntaxList<CollectionElementSyntax> elements = collectionExpression.Elements;
+
+        IArrayTypeSymbol arrayTypeSymbol = null;
+        var isObvious = false;
+
+        foreach (CollectionElementSyntax element in elements)
+        {
+            if (element is not ExpressionElementSyntax expressionElement)
+                return false;
+
+            if (arrayTypeSymbol is null)
+            {
+                ITypeSymbol type = context.SemanticModel.GetTypeInfo(collectionExpression, context.CancellationToken).ConvertedType;
+
+                arrayTypeSymbol = type as IArrayTypeSymbol;
+
+                if (arrayTypeSymbol?.ElementType.SupportsExplicitDeclaration() != true)
+                    return true;
+            }
+
+            isObvious = CSharpTypeAnalysis.IsTypeObvious(expressionElement.Expression, arrayTypeSymbol.ElementType, includeNullability: true, context.SemanticModel, context.CancellationToken);
+
+            if (!isObvious)
+                return false;
+        }
+
+        return isObvious;
+    }
+
+    protected override bool UseCollectionExpressionFromImplicit(ref SyntaxNodeAnalysisContext context)
+    {
+        return UseCollectionExpression(ref context);
+    }
+
+    public override TypeStyle GetTypeStyle(ref SyntaxNodeAnalysisContext context)
+    {
+        return context.GetArrayCreationTypeStyle();
+    }
+
+    protected override void ReportExplicitToImplicit(ref SyntaxNodeAnalysisContext context)
+    {
+        DiagnosticHelpers.ReportDiagnostic(
+            context,
+            DiagnosticRules.UseExplicitlyOrImplicitlyTypedArray,
+            GetLocationFromExplicit(ref context),
+            "Simplify array creation");
+    }
+
+    protected override void ReportExplicitToCollectionExpression(ref SyntaxNodeAnalysisContext context)
+    {
+        DiagnosticHelpers.ReportDiagnostic(
+            context,
+            DiagnosticRules.UseExplicitlyOrImplicitlyTypedArray,
+            GetLocationFromExplicit(ref context),
+            properties: _explicitToCollectionExpression,
+            "Simplify array creation");
+    }
+
+    private static Location GetLocationFromExplicit(ref SyntaxNodeAnalysisContext context)
+    {
+        return ((ArrayCreationExpressionSyntax)context.Node).Type.ElementType.GetLocation();
+    }
+
+    protected override void ReportImplicitToExplicit(ref SyntaxNodeAnalysisContext context)
+    {
+        if (context.Node is CollectionExpressionSyntax collectionExpression
+            && !CanConvertCollectionExpression(ref context, collectionExpression))
+        {
+            return;
+        }
+
+        DiagnosticHelpers.ReportDiagnostic(
+            context,
+            DiagnosticRules.UseExplicitlyOrImplicitlyTypedArray,
+            GetLocationFromImplicit(ref context),
+            "Use explicitly typed array");
+    }
+
+    protected override void ReportImplicitToCollectionExpression(ref SyntaxNodeAnalysisContext context)
+    {
+        DiagnosticHelpers.ReportDiagnostic(
+            context,
+            DiagnosticRules.UseExplicitlyOrImplicitlyTypedArray,
+            GetLocationFromImplicit(ref context),
+            properties: _implicitToCollectionExpression,
+            "Simplify array creation");
+    }
+
+    private static Location GetLocationFromImplicit(ref SyntaxNodeAnalysisContext context)
+    {
+        if (context.Node is ImplicitArrayCreationExpressionSyntax implicitCreation)
+        {
+            return Location.Create(
+                implicitCreation.SyntaxTree,
+                TextSpan.FromBounds(implicitCreation.NewKeyword.SpanStart, implicitCreation.CloseBracketToken.Span.End));
+        }
+
+        return context.Node.GetLocation();
+    }
+
+    protected override void ReportCollectionExpressionToImplicit(ref SyntaxNodeAnalysisContext context)
+    {
+        var collectionExpression = (CollectionExpressionSyntax)context.Node;
+
+        if (!CanConvertCollectionExpression(ref context, collectionExpression))
+            return;
+
+        DiagnosticHelpers.ReportDiagnostic(
+            context,
+            DiagnosticRules.UseExplicitlyOrImplicitlyTypedArray,
+            context.Node.GetLocation(),
+            properties: _collectionExpressionToImplicit,
+            "Simplify array creation");
+    }
+
+    private static bool CanConvertCollectionExpression(ref SyntaxNodeAnalysisContext context, CollectionExpressionSyntax collectionExpression)
+    {
+        foreach (CollectionElementSyntax element in collectionExpression.Elements)
+        {
+            if (element is SpreadElementSyntax)
+                return false;
+        }
+
+        return context.SemanticModel
+            .GetTypeInfo(context.Node, context.CancellationToken)
+            .ConvertedType?
+            .IsKind(SymbolKind.ArrayType) == true;
+    }
+}
diff --git a/src/Analyzers/CSharp/Analysis/ObjectCreation/ImplicitOrExpressionObjectCreationAnalysis.cs b/src/Analyzers/CSharp/Analysis/ObjectCreation/ImplicitOrExpressionObjectCreationAnalysis.cs
new file mode 100644
index 0000000000..280b58756c
--- /dev/null
+++ b/src/Analyzers/CSharp/Analysis/ObjectCreation/ImplicitOrExpressionObjectCreationAnalysis.cs
@@ -0,0 +1,75 @@
+// Copyright (c) .NET Foundation and Contributors. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Roslynator.CSharp.CodeStyle;
+
+namespace Roslynator.CSharp.Analysis;
+
+internal class ImplicitOrExpressionObjectCreationAnalysis : ImplicitOrExplicitCreationAnalysis
+{
+    public static ImplicitOrExpressionObjectCreationAnalysis Instance { get; } = new();
+
+    public override TypeStyle GetTypeStyle(ref SyntaxNodeAnalysisContext context)
+    {
+        return context.GetObjectCreationTypeStyle();
+    }
+
+    protected override bool UseCollectionExpressionFromImplicit(ref SyntaxNodeAnalysisContext context)
+    {
+        return ((ImplicitObjectCreationExpressionSyntax)context.Node).ArgumentList?.Arguments.Any() != true
+            && UseCollectionExpression(ref context);
+    }
+
+    protected override void ReportExplicitToImplicit(ref SyntaxNodeAnalysisContext context)
+    {
+        var objectCreation = (ObjectCreationExpressionSyntax)context.Node;
+
+        DiagnosticHelpers.ReportDiagnostic(
+            context,
+            DiagnosticRules.UseImplicitOrExplicitObjectCreation,
+            objectCreation.Type.GetLocation(),
+            "Simplify array creation");
+    }
+
+    protected override void ReportExplicitToCollectionExpression(ref SyntaxNodeAnalysisContext context)
+    {
+        var objectCreation = (ObjectCreationExpressionSyntax)context.Node;
+
+        DiagnosticHelpers.ReportDiagnostic(
+            context,
+            DiagnosticRules.UseImplicitOrExplicitObjectCreation,
+            objectCreation.Type.GetLocation(),
+            properties: _explicitToCollectionExpression,
+            "Simplify array creation");
+    }
+
+    protected override void ReportImplicitToExplicit(ref SyntaxNodeAnalysisContext context)
+    {
+        DiagnosticHelpers.ReportDiagnostic(
+            context,
+            DiagnosticRules.UseImplicitOrExplicitObjectCreation,
+            context.Node,
+            "Use explicit object creation");
+    }
+
+    protected override void ReportImplicitToCollectionExpression(ref SyntaxNodeAnalysisContext context)
+    {
+        DiagnosticHelpers.ReportDiagnostic(
+            context,
+            DiagnosticRules.UseImplicitOrExplicitObjectCreation,
+            context.Node.GetLocation(),
+            properties: _implicitToCollectionExpression,
+            "Simplify array creation");
+    }
+
+    protected override void ReportCollectionExpressionToImplicit(ref SyntaxNodeAnalysisContext context)
+    {
+        DiagnosticHelpers.ReportDiagnostic(
+            context,
+            DiagnosticRules.UseImplicitOrExplicitObjectCreation,
+            context.Node.GetLocation(),
+            properties: _collectionExpressionToImplicit,
+            "Simplify array creation");
+    }
+}
diff --git a/src/Analyzers/CSharp/Analysis/UseExplicitlyOrImplicitlyTypedArrayAnalyzer.cs b/src/Analyzers/CSharp/Analysis/UseExplicitlyOrImplicitlyTypedArrayAnalyzer.cs
index 0e3d5df6ec..60764a4fb1 100644
--- a/src/Analyzers/CSharp/Analysis/UseExplicitlyOrImplicitlyTypedArrayAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analysis/UseExplicitlyOrImplicitlyTypedArrayAnalyzer.cs
@@ -3,10 +3,7 @@
 using System.Collections.Immutable;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
-using Microsoft.CodeAnalysis.Text;
-using Roslynator.CSharp.CodeStyle;
 
 namespace Roslynator.CSharp.Analysis;
 
@@ -20,9 +17,7 @@ public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
         get
         {
             if (_supportedDiagnostics.IsDefault)
-            {
                 Immutable.InterlockedInitialize(ref _supportedDiagnostics, DiagnosticRules.UseExplicitlyOrImplicitlyTypedArray);
-            }
 
             return _supportedDiagnostics;
         }
@@ -32,146 +27,23 @@ public override void Initialize(AnalysisContext context)
     {
         base.Initialize(context);
 
-        context.RegisterSyntaxNodeAction(
-            c =>
-            {
-                ArrayCreationTypeStyle style = c.GetArrayCreationTypeStyle();
-
-                if (style == ArrayCreationTypeStyle.Explicit
-                    || style == ArrayCreationTypeStyle.ImplicitWhenTypeIsObvious)
-                {
-                    AnalyzeImplicitArrayCreationExpression(c, style);
-                }
-            },
-            SyntaxKind.ImplicitArrayCreationExpression);
-
-        context.RegisterSyntaxNodeAction(
-            c =>
-            {
-                ArrayCreationTypeStyle style = c.GetArrayCreationTypeStyle();
-
-                if (style == ArrayCreationTypeStyle.Implicit
-                    || style == ArrayCreationTypeStyle.ImplicitWhenTypeIsObvious)
-                {
-                    AnalyzeArrayCreationExpression(c, style);
-                }
-            },
-            SyntaxKind.ArrayCreationExpression);
+        context.RegisterSyntaxNodeAction(c => AnalyzeArrayCreationExpression(c), SyntaxKind.ArrayCreationExpression);
+        context.RegisterSyntaxNodeAction(c => AnalyzeImplicitArrayCreationExpression(c), SyntaxKind.ImplicitArrayCreationExpression);
+        context.RegisterSyntaxNodeAction(c => AnalyzeCollectionExpression(c), SyntaxKind.CollectionExpression);
     }
 
-    private static void AnalyzeImplicitArrayCreationExpression(SyntaxNodeAnalysisContext context, ArrayCreationTypeStyle kind)
+    private static void AnalyzeArrayCreationExpression(SyntaxNodeAnalysisContext context)
     {
-        var expression = (ImplicitArrayCreationExpressionSyntax)context.Node;
-
-        if (expression.ContainsDiagnostics)
-            return;
-
-        if (expression.NewKeyword.ContainsDirectives)
-            return;
-
-        if (expression.OpenBracketToken.ContainsDirectives)
-            return;
-
-        if (expression.CloseBracketToken.ContainsDirectives)
-            return;
-
-        IArrayTypeSymbol arrayTypeSymbol = null;
-
-        if (kind == ArrayCreationTypeStyle.ImplicitWhenTypeIsObvious)
-        {
-            InitializerExpressionSyntax initializer = expression.Initializer;
-
-            if (initializer is not null)
-            {
-                var isObvious = false;
-
-                foreach (ExpressionSyntax expression2 in initializer.Expressions)
-                {
-                    if (arrayTypeSymbol is null)
-                    {
-                        arrayTypeSymbol = context.SemanticModel.GetTypeSymbol(expression, context.CancellationToken) as IArrayTypeSymbol;
-
-                        if (arrayTypeSymbol?.ElementType.SupportsExplicitDeclaration() != true)
-                            return;
-                    }
-
-                    isObvious = CSharpTypeAnalysis.IsTypeObvious(expression2, arrayTypeSymbol.ElementType, includeNullability: true, context.SemanticModel, context.CancellationToken);
-
-                    if (!isObvious)
-                        break;
-                }
-
-                if (isObvious)
-                    return;
-            }
-        }
-
-        if (arrayTypeSymbol is null)
-        {
-            arrayTypeSymbol = context.SemanticModel.GetTypeSymbol(expression, context.CancellationToken) as IArrayTypeSymbol;
-
-            if (arrayTypeSymbol?.ElementType.SupportsExplicitDeclaration() != true)
-                return;
-        }
-
-        Location location = Location.Create(expression.SyntaxTree, TextSpan.FromBounds(expression.NewKeyword.SpanStart, expression.CloseBracketToken.Span.End));
-
-        DiagnosticHelpers.ReportDiagnostic(
-            context,
-            DiagnosticRules.UseExplicitlyOrImplicitlyTypedArray,
-            location,
-            "explicitly");
+        ImplicitOrExpressionArrayCreationAnalysis.Instance.AnalyzeExplicitCreation(ref context);
     }
 
-    private static void AnalyzeArrayCreationExpression(SyntaxNodeAnalysisContext context, ArrayCreationTypeStyle kind)
+    private static void AnalyzeImplicitArrayCreationExpression(SyntaxNodeAnalysisContext context)
     {
-        var arrayCreation = (ArrayCreationExpressionSyntax)context.Node;
-
-        if (arrayCreation.ContainsDiagnostics)
-            return;
-
-        ArrayTypeSyntax arrayType = arrayCreation.Type;
-
-        if (arrayType.ContainsDirectives)
-            return;
-
-        SeparatedSyntaxList<ExpressionSyntax> expressions = arrayCreation.Initializer?.Expressions ?? default;
-
-        if (!expressions.Any())
-            return;
-
-        ITypeSymbol typeSymbol = null;
-
-        if (kind == ArrayCreationTypeStyle.ImplicitWhenTypeIsObvious)
-        {
-            foreach (ExpressionSyntax expression in expressions)
-            {
-                if (typeSymbol is null)
-                {
-                    typeSymbol = context.SemanticModel.GetTypeSymbol(arrayCreation.Type.ElementType, context.CancellationToken);
-
-                    if (typeSymbol?.IsErrorType() != false)
-                        return;
-                }
-
-                if (!CSharpTypeAnalysis.IsTypeObvious(expression, typeSymbol, includeNullability: true, context.SemanticModel, context.CancellationToken))
-                    return;
-            }
-        }
-
-        TypeSyntax elementType = arrayType.ElementType;
-        SyntaxList<ArrayRankSpecifierSyntax> rankSpecifiers = arrayType.RankSpecifiers;
-
-        TextSpan textSpan = TextSpan.FromBounds(
-            elementType.SpanStart,
-            ((rankSpecifiers.Count > 1) ? rankSpecifiers.LastButOne() : (SyntaxNode)elementType).Span.End);
-
-        Location location = Location.Create(arrayCreation.SyntaxTree, textSpan);
+        ImplicitOrExpressionArrayCreationAnalysis.Instance.AnalyzeImplicitCreation(ref context);
+    }
 
-        DiagnosticHelpers.ReportDiagnostic(
-            context,
-            DiagnosticRules.UseExplicitlyOrImplicitlyTypedArray,
-            location,
-            "implicitly");
+    private static void AnalyzeCollectionExpression(SyntaxNodeAnalysisContext context)
+    {
+        ImplicitOrExpressionArrayCreationAnalysis.Instance.AnalyzeCollectionExpression(ref context);
     }
 }
diff --git a/src/Analyzers/CSharp/Analysis/UseImplicitOrExplicitObjectCreationAnalyzer.cs b/src/Analyzers/CSharp/Analysis/UseImplicitOrExplicitObjectCreationAnalyzer.cs
index bdf0f20c95..ac29469529 100644
--- a/src/Analyzers/CSharp/Analysis/UseImplicitOrExplicitObjectCreationAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analysis/UseImplicitOrExplicitObjectCreationAnalyzer.cs
@@ -1,12 +1,9 @@
 // Copyright (c) .NET Foundation and Contributors. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System.Collections.Immutable;
-using System.Linq;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
-using Roslynator.CSharp.CodeStyle;
 
 namespace Roslynator.CSharp.Analysis;
 
@@ -34,581 +31,26 @@ public override void Initialize(AnalysisContext context)
         {
             if (((CSharpCompilation)startContext.Compilation).LanguageVersion >= LanguageVersion.CSharp9)
             {
-                startContext.RegisterSyntaxNodeAction(f => AnalyzeObjectCreationExpression(f), SyntaxKind.ObjectCreationExpression);
+                startContext.RegisterSyntaxNodeAction(c => AnalyzeObjectCreationExpression(c), SyntaxKind.ObjectCreationExpression);
             }
 
-            startContext.RegisterSyntaxNodeAction(f => AnalyzeImplicitObjectCreationExpression(f), SyntaxKind.ImplicitObjectCreationExpression);
+            startContext.RegisterSyntaxNodeAction(c => AnalyzeImplicitObjectCreationExpression(c), SyntaxKind.ImplicitObjectCreationExpression);
+            startContext.RegisterSyntaxNodeAction(c => AnalyzeCollectionExpression(c), SyntaxKind.CollectionExpression);
         });
     }
 
     private static void AnalyzeObjectCreationExpression(SyntaxNodeAnalysisContext context)
     {
-        var objectCreation = (ObjectCreationExpressionSyntax)context.Node;
-
-        SyntaxNode parent = objectCreation.Parent;
-
-        switch (parent.Kind())
-        {
-            case SyntaxKind.ThrowExpression:
-            case SyntaxKind.ThrowStatement:
-                {
-                    if (UseImplicitObjectCreation(context)
-                        && context.SemanticModel.GetTypeSymbol(objectCreation, context.CancellationToken)?
-                            .HasMetadataName(MetadataNames.System_Exception) == true)
-                    {
-                        ReportDiagnostic(context, objectCreation);
-                    }
-
-                    break;
-                }
-            case SyntaxKind.EqualsValueClause:
-                {
-                    if (!UseImplicitObjectCreation(context))
-                        return;
-
-                    parent = parent.Parent;
-
-                    SyntaxDebug.Assert(parent.IsKind(SyntaxKind.VariableDeclarator, SyntaxKind.PropertyDeclaration), parent);
-
-                    if (parent.IsKind(SyntaxKind.VariableDeclarator))
-                    {
-                        parent = parent.Parent;
-
-                        if (parent is VariableDeclarationSyntax variableDeclaration)
-                        {
-                            SyntaxDebug.Assert(parent.IsParentKind(SyntaxKind.FieldDeclaration, SyntaxKind.LocalDeclarationStatement, SyntaxKind.UsingStatement), parent.Parent);
-
-                            if (parent.IsParentKind(SyntaxKind.FieldDeclaration))
-                            {
-                                AnalyzeType(context, objectCreation, variableDeclaration.Type);
-                            }
-                            else if (parent.IsParentKind(SyntaxKind.LocalDeclarationStatement, SyntaxKind.UsingStatement))
-                            {
-                                if (context.UseVarInsteadOfImplicitObjectCreation() == false)
-                                {
-                                    if (variableDeclaration.Type.IsVar)
-                                    {
-                                        ReportDiagnostic(context, objectCreation);
-                                    }
-                                    else
-                                    {
-                                        AnalyzeType(context, objectCreation, variableDeclaration.Type);
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    else if (parent.IsKind(SyntaxKind.PropertyDeclaration))
-                    {
-                        AnalyzeType(context, objectCreation, ((PropertyDeclarationSyntax)parent).Type);
-                    }
-
-                    break;
-                }
-            case SyntaxKind.ArrowExpressionClause:
-                {
-                    if (UseImplicitObjectCreation(context))
-                    {
-                        TypeSyntax type = DetermineReturnType(parent.Parent);
-
-                        SyntaxDebug.Assert(type is not null, parent);
-
-                        if (type is not null)
-                            AnalyzeType(context, objectCreation, type);
-                    }
-
-                    break;
-                }
-            case SyntaxKind.ArrayInitializerExpression:
-                {
-                    SyntaxDebug.Assert(parent.IsParentKind(SyntaxKind.ArrayCreationExpression, SyntaxKind.ImplicitArrayCreationExpression, SyntaxKind.EqualsValueClause, SyntaxKind.ImplicitStackAllocArrayCreationExpression), parent.Parent);
-
-                    if (UseImplicitObjectCreation(context))
-                    {
-                        if (parent.IsParentKind(SyntaxKind.ArrayCreationExpression))
-                        {
-                            var arrayCreationExpression = (ArrayCreationExpressionSyntax)parent.Parent;
-
-                            AnalyzeType(context, objectCreation, arrayCreationExpression.Type.ElementType);
-                        }
-                        else if (parent.IsParentKind(SyntaxKind.EqualsValueClause))
-                        {
-                            parent = parent.Parent.Parent;
-
-                            if (parent.IsKind(SyntaxKind.VariableDeclarator))
-                            {
-                                parent = parent.Parent;
-
-                                if (parent is VariableDeclarationSyntax variableDeclaration)
-                                {
-                                    if (parent.IsParentKind(SyntaxKind.FieldDeclaration))
-                                    {
-                                        AnalyzeArrayType(context, objectCreation, variableDeclaration.Type);
-                                    }
-                                    else if (parent.IsParentKind(SyntaxKind.LocalDeclarationStatement, SyntaxKind.UsingStatement))
-                                    {
-                                        if (!variableDeclaration.Type.IsVar)
-                                            AnalyzeArrayType(context, objectCreation, variableDeclaration.Type);
-                                    }
-                                }
-                            }
-                            else if (parent.IsKind(SyntaxKind.PropertyDeclaration))
-                            {
-                                AnalyzeArrayType(context, objectCreation, ((PropertyDeclarationSyntax)parent).Type);
-                            }
-                        }
-                    }
-
-                    break;
-                }
-            case SyntaxKind.ReturnStatement:
-            case SyntaxKind.YieldReturnStatement:
-                {
-                    if (!UseImplicitObjectCreationWhenTypeIsNotObvious(context))
-                        return;
-
-                    for (SyntaxNode node = parent.Parent; node is not null; node = node.Parent)
-                    {
-                        if (CSharpFacts.IsAnonymousFunctionExpression(node.Kind()))
-                            return;
-
-                        TypeSyntax type = DetermineReturnType(node);
-
-                        if (type is not null)
-                        {
-                            if (parent.IsKind(SyntaxKind.YieldReturnStatement))
-                            {
-                                ITypeSymbol typeSymbol = context.SemanticModel.GetTypeSymbol(type, context.CancellationToken);
-
-                                if (typeSymbol?.OriginalDefinition.SpecialType == SpecialType.System_Collections_Generic_IEnumerable_T)
-                                {
-                                    var ienumerableOfT = (INamedTypeSymbol)typeSymbol;
-
-                                    ITypeSymbol typeSymbol2 = ienumerableOfT.TypeArguments.Single();
-
-                                    AnalyzeTypeSymbol(context, objectCreation, typeSymbol2);
-                                }
-                            }
-                            else
-                            {
-                                AnalyzeType(context, objectCreation, type);
-                            }
-
-                            return;
-                        }
-                    }
-
-                    break;
-                }
-            case SyntaxKind.SimpleAssignmentExpression:
-            case SyntaxKind.CoalesceAssignmentExpression:
-            case SyntaxKind.AddAssignmentExpression:
-            case SyntaxKind.SubtractAssignmentExpression:
-                {
-                    if (UseImplicitObjectCreationWhenTypeIsNotObvious(context))
-                    {
-                        var assignment = (AssignmentExpressionSyntax)parent;
-                        AnalyzeExpression(context, objectCreation, assignment.Left);
-                    }
-
-                    break;
-                }
-            case SyntaxKind.CoalesceExpression:
-                {
-                    ObjectCreationTypeStyle style = context.GetObjectCreationTypeStyle();
-
-                    if (style == ObjectCreationTypeStyle.Implicit)
-                    {
-                        var coalesceExpression = (BinaryExpressionSyntax)parent;
-                        AnalyzeExpression(context, objectCreation, coalesceExpression.Left);
-                    }
-                    else if (style == ObjectCreationTypeStyle.ImplicitWhenTypeIsObvious
-                        && parent.IsParentKind(SyntaxKind.EqualsValueClause))
-                    {
-                        if (parent.Parent.Parent is VariableDeclaratorSyntax variableDeclarator)
-                        {
-                            if (variableDeclarator.Parent is VariableDeclarationSyntax variableDeclaration
-                                && variableDeclaration.IsParentKind(SyntaxKind.FieldDeclaration))
-                            {
-                                AnalyzeType(context, objectCreation, variableDeclaration.Type);
-                            }
-                        }
-                        else if (parent.Parent.Parent is PropertyDeclarationSyntax propertyDeclaration)
-                        {
-                            AnalyzeType(context, objectCreation, propertyDeclaration.Type);
-                        }
-                    }
-
-                    break;
-                }
-            case SyntaxKind.CollectionInitializerExpression:
-                {
-                    SyntaxDebug.Assert(parent.IsParentKind(SyntaxKind.ObjectCreationExpression, SyntaxKind.ImplicitObjectCreationExpression, SyntaxKind.SimpleAssignmentExpression), parent.Parent);
-
-                    if (!UseImplicitObjectCreation(context))
-                        return;
-
-                    parent = parent.Parent;
-                    if (parent.IsKind(SyntaxKind.ObjectCreationExpression, SyntaxKind.ImplicitObjectCreationExpression))
-                    {
-                        SyntaxNode parentObjectCreation = parent;
-
-                        parent = parent.Parent;
-                        if (parent.IsKind(SyntaxKind.EqualsValueClause))
-                        {
-                            parent = parent.Parent;
-                            if (parent.IsKind(SyntaxKind.VariableDeclarator))
-                            {
-                                parent = parent.Parent;
-                                if (parent is VariableDeclarationSyntax variableDeclaration
-                                    && parent.IsParentKind(SyntaxKind.FieldDeclaration, SyntaxKind.LocalDeclarationStatement))
-                                {
-                                    if (parentObjectCreation is ExpressionSyntax parentObjectCreationExpression)
-                                    {
-                                        AnalyzeExpression(context, objectCreation, parentObjectCreationExpression, isGenericType: true);
-                                    }
-                                    else
-                                    {
-                                        AnalyzeType(context, objectCreation, variableDeclaration.Type, isGenericType: true);
-                                    }
-                                }
-                            }
-                            else if (parent.IsKind(SyntaxKind.PropertyDeclaration))
-                            {
-                                AnalyzeType(context, objectCreation, ((PropertyDeclarationSyntax)parent).Type);
-                            }
-                        }
-                    }
-
-                    break;
-                }
-            case SyntaxKind.ComplexElementInitializerExpression:
-                {
-                    break;
-                }
-        }
+        ImplicitOrExpressionObjectCreationAnalysis.Instance.AnalyzeExplicitCreation(ref context);
     }
 
     private static void AnalyzeImplicitObjectCreationExpression(SyntaxNodeAnalysisContext context)
     {
-        var implicitObjectCreation = (ImplicitObjectCreationExpressionSyntax)context.Node;
-
-        SyntaxNode parent = implicitObjectCreation.Parent;
-
-        switch (parent.Kind())
-        {
-            case SyntaxKind.ThrowExpression:
-            case SyntaxKind.ThrowStatement:
-                {
-                    if (UseExplicitObjectCreation(context)
-                        && context.SemanticModel.GetTypeSymbol(implicitObjectCreation, context.CancellationToken)?
-                            .HasMetadataName(MetadataNames.System_Exception) == true)
-                    {
-                        ReportDiagnostic(context, implicitObjectCreation);
-                    }
-
-                    break;
-                }
-            case SyntaxKind.EqualsValueClause:
-                {
-                    parent = parent.Parent;
-
-                    SyntaxDebug.Assert(parent.IsKind(SyntaxKind.VariableDeclarator, SyntaxKind.PropertyDeclaration, SyntaxKind.Parameter), parent);
-
-                    if (parent.IsKind(SyntaxKind.VariableDeclarator))
-                    {
-                        parent = parent.Parent;
-
-                        if (parent is VariableDeclarationSyntax variableDeclaration)
-                        {
-                            SyntaxDebug.Assert(!variableDeclaration.Type.IsVar, variableDeclaration);
-
-                            SyntaxDebug.Assert(parent.IsParentKind(SyntaxKind.FieldDeclaration, SyntaxKind.LocalDeclarationStatement, SyntaxKind.UsingStatement), parent.Parent);
-
-                            if (UseExplicitObjectCreation(context))
-                            {
-                                ReportDiagnostic(context, implicitObjectCreation);
-                            }
-                            else if (parent.IsParentKind(SyntaxKind.LocalDeclarationStatement, SyntaxKind.UsingStatement)
-                                && variableDeclaration.Variables.Count == 1
-                                && !variableDeclaration.Type.IsVar
-                                && context.UseVarInsteadOfImplicitObjectCreation() == true)
-                            {
-                                DiagnosticHelpers.ReportDiagnostic(context, DiagnosticRules.UseImplicitOrExplicitObjectCreation, variableDeclaration, "explicit");
-                            }
-                        }
-                    }
-                    else if (parent.IsKind(SyntaxKind.PropertyDeclaration))
-                    {
-                        if (UseExplicitObjectCreation(context))
-                            ReportDiagnostic(context, implicitObjectCreation);
-                    }
-
-                    break;
-                }
-            case SyntaxKind.ArrowExpressionClause:
-                {
-                    if (UseExplicitObjectCreation(context))
-                    {
-                        TypeSyntax type = DetermineReturnType(parent.Parent);
-
-                        SyntaxDebug.Assert(type is not null, parent);
-
-                        if (type is not null)
-                            ReportDiagnostic(context, implicitObjectCreation);
-                    }
-
-                    return;
-                }
-            case SyntaxKind.ArrayInitializerExpression:
-                {
-                    SyntaxDebug.Assert(parent.IsParentKind(SyntaxKind.ArrayCreationExpression, SyntaxKind.ImplicitArrayCreationExpression, SyntaxKind.EqualsValueClause), parent.Parent);
-
-                    if (UseExplicitObjectCreation(context)
-                        && parent.IsParentKind(SyntaxKind.ArrayCreationExpression))
-                    {
-                        ReportDiagnostic(context, implicitObjectCreation);
-                    }
-
-                    break;
-                }
-            case SyntaxKind.ReturnStatement:
-            case SyntaxKind.YieldReturnStatement:
-                {
-                    if (!UseExplicitObjectCreationWhenTypeIsNotObvious(context))
-                        return;
-
-                    for (SyntaxNode node = parent.Parent; node is not null; node = node.Parent)
-                    {
-                        if (CSharpFacts.IsAnonymousFunctionExpression(node.Kind()))
-                            return;
-
-                        TypeSyntax type = DetermineReturnType(node);
-
-                        if (type is not null)
-                        {
-                            if (parent.IsKind(SyntaxKind.YieldReturnStatement))
-                            {
-                                ITypeSymbol typeSymbol = context.SemanticModel.GetTypeSymbol(type, context.CancellationToken);
-
-                                if (typeSymbol?.OriginalDefinition.SpecialType == SpecialType.System_Collections_Generic_IEnumerable_T)
-                                {
-                                    ReportDiagnostic(context, implicitObjectCreation);
-                                }
-                            }
-                            else
-                            {
-                                ReportDiagnostic(context, implicitObjectCreation);
-                            }
-                        }
-                    }
-
-                    break;
-                }
-            case SyntaxKind.SimpleAssignmentExpression:
-            case SyntaxKind.CoalesceAssignmentExpression:
-            case SyntaxKind.AddAssignmentExpression:
-            case SyntaxKind.SubtractAssignmentExpression:
-                {
-                    if (UseExplicitObjectCreationWhenTypeIsNotObvious(context))
-                        ReportDiagnostic(context, implicitObjectCreation);
-
-                    break;
-                }
-            case SyntaxKind.CoalesceExpression:
-                {
-                    if (parent.IsParentKind(SyntaxKind.EqualsValueClause))
-                    {
-                        switch (parent.Parent.Parent)
-                        {
-                            case VariableDeclaratorSyntax variableDeclarator:
-                                {
-                                    if (variableDeclarator.Parent is VariableDeclarationSyntax)
-                                    {
-                                        if (UseExplicitObjectCreation(context))
-                                            ReportDiagnostic(context, implicitObjectCreation);
-
-                                        return;
-                                    }
-
-                                    break;
-                                }
-                            case PropertyDeclarationSyntax:
-                                {
-                                    if (UseExplicitObjectCreation(context))
-                                        ReportDiagnostic(context, implicitObjectCreation);
-
-                                    return;
-                                }
-                        }
-                    }
-
-                    if (UseExplicitObjectCreationWhenTypeIsNotObvious(context))
-                        ReportDiagnostic(context, implicitObjectCreation);
-
-                    break;
-                }
-            case SyntaxKind.CollectionInitializerExpression:
-                {
-                    SyntaxDebug.Assert(parent.IsParentKind(SyntaxKind.ObjectCreationExpression, SyntaxKind.ImplicitObjectCreationExpression, SyntaxKind.SimpleAssignmentExpression), parent.Parent);
-
-                    if (!UseExplicitObjectCreation(context))
-                        return;
-
-                    parent = parent.Parent;
-                    if (parent.IsKind(SyntaxKind.ObjectCreationExpression, SyntaxKind.ImplicitObjectCreationExpression))
-                    {
-                        parent = parent.Parent;
-                        if (parent.IsKind(SyntaxKind.EqualsValueClause))
-                        {
-                            parent = parent.Parent;
-                            if (parent.IsKind(SyntaxKind.VariableDeclarator))
-                            {
-                                parent = parent.Parent;
-                                if (parent is VariableDeclarationSyntax)
-                                {
-                                    SyntaxDebug.Assert(parent.IsParentKind(SyntaxKind.FieldDeclaration, SyntaxKind.LocalDeclarationStatement, SyntaxKind.UsingStatement), parent.Parent);
-
-                                    if (UseExplicitObjectCreation(context))
-                                        ReportDiagnostic(context, implicitObjectCreation);
-                                }
-                            }
-                            else if (parent.IsKind(SyntaxKind.PropertyDeclaration))
-                            {
-                                if (UseExplicitObjectCreation(context))
-                                    ReportDiagnostic(context, implicitObjectCreation);
-                            }
-                        }
-                    }
-
-                    break;
-                }
-            case SyntaxKind.ComplexElementInitializerExpression:
-                {
-                    break;
-                }
-        }
-    }
-
-    private static bool UseExplicitObjectCreation(SyntaxNodeAnalysisContext context)
-    {
-        return context.GetObjectCreationTypeStyle() == ObjectCreationTypeStyle.Explicit;
-    }
-
-    private static bool UseImplicitObjectCreation(SyntaxNodeAnalysisContext context)
-    {
-        ObjectCreationTypeStyle style = context.GetObjectCreationTypeStyle();
-
-        return style == ObjectCreationTypeStyle.Implicit
-            || style == ObjectCreationTypeStyle.ImplicitWhenTypeIsObvious;
-    }
-
-    private static bool UseImplicitObjectCreationWhenTypeIsNotObvious(SyntaxNodeAnalysisContext context)
-    {
-        return context.GetObjectCreationTypeStyle() == ObjectCreationTypeStyle.Implicit;
-    }
-
-    private static bool UseExplicitObjectCreationWhenTypeIsNotObvious(SyntaxNodeAnalysisContext context)
-    {
-        ObjectCreationTypeStyle style = context.GetObjectCreationTypeStyle();
-
-        return style == ObjectCreationTypeStyle.Explicit
-            || style == ObjectCreationTypeStyle.ImplicitWhenTypeIsObvious;
-    }
-
-    private static void AnalyzeType(
-        SyntaxNodeAnalysisContext context,
-        ObjectCreationExpressionSyntax objectCreation,
-        TypeSyntax type,
-        bool isGenericType = false)
-    {
-        if (!type.IsVar)
-        {
-            AnalyzeExpression(context, objectCreation, type, isGenericType: isGenericType);
-        }
-    }
-
-    private static void AnalyzeArrayType(
-        SyntaxNodeAnalysisContext context,
-        ObjectCreationExpressionSyntax objectCreation,
-        TypeSyntax type,
-        bool isGenericType = false)
-    {
-        if (type is ArrayTypeSyntax arrayType)
-        {
-            type = arrayType.ElementType;
-
-            if (!type.IsVar)
-                AnalyzeExpression(context, objectCreation, type, isGenericType: isGenericType);
-        }
-    }
-
-    private static void AnalyzeExpression(
-        SyntaxNodeAnalysisContext context,
-        ObjectCreationExpressionSyntax objectCreation,
-        ExpressionSyntax expression,
-        bool isGenericType = false)
-    {
-        ITypeSymbol typeSymbol1 = context.SemanticModel.GetTypeSymbol(expression);
-
-        if (isGenericType)
-        {
-            typeSymbol1 = (typeSymbol1 as INamedTypeSymbol)?.TypeArguments.SingleOrDefault(shouldThrow: false);
-        }
-
-        AnalyzeTypeSymbol(context, objectCreation, typeSymbol1);
-    }
-
-    private static void AnalyzeTypeSymbol(
-        SyntaxNodeAnalysisContext context,
-        ObjectCreationExpressionSyntax objectCreation,
-        ITypeSymbol typeSymbol1)
-    {
-        if (typeSymbol1?.IsErrorType() == false)
-        {
-            ITypeSymbol typeSymbol2 = context.SemanticModel.GetTypeSymbol(objectCreation);
-
-            if (SymbolEqualityComparer.Default.Equals(typeSymbol1, typeSymbol2))
-                ReportDiagnostic(context, objectCreation);
-        }
-    }
-
-    private static TypeSyntax DetermineReturnType(SyntaxNode node)
-    {
-        switch (node.Kind())
-        {
-            case SyntaxKind.LocalFunctionStatement:
-                return ((LocalFunctionStatementSyntax)node).ReturnType;
-            case SyntaxKind.MethodDeclaration:
-                return ((MethodDeclarationSyntax)node).ReturnType;
-            case SyntaxKind.OperatorDeclaration:
-                return ((OperatorDeclarationSyntax)node).ReturnType;
-            case SyntaxKind.ConversionOperatorDeclaration:
-                return ((ConversionOperatorDeclarationSyntax)node).Type;
-            case SyntaxKind.PropertyDeclaration:
-                return ((PropertyDeclarationSyntax)node).Type;
-            case SyntaxKind.IndexerDeclaration:
-                return ((IndexerDeclarationSyntax)node).Type;
-        }
-
-        if (node is AccessorDeclarationSyntax)
-        {
-            SyntaxDebug.Assert(node.IsParentKind(SyntaxKind.AccessorList), node.Parent);
-
-            if (node.IsParentKind(SyntaxKind.AccessorList))
-                return DetermineReturnType(node.Parent.Parent);
-        }
-
-        return null;
-    }
-
-    private static void ReportDiagnostic(SyntaxNodeAnalysisContext context, ObjectCreationExpressionSyntax objectCreation)
-    {
-        DiagnosticHelpers.ReportDiagnostic(context, DiagnosticRules.UseImplicitOrExplicitObjectCreation, objectCreation.Type, "implicit");
+        ImplicitOrExpressionObjectCreationAnalysis.Instance.AnalyzeImplicitCreation(ref context);
     }
 
-    private static void ReportDiagnostic(SyntaxNodeAnalysisContext context, ImplicitObjectCreationExpressionSyntax implicitObjectCreation)
+    private static void AnalyzeCollectionExpression(SyntaxNodeAnalysisContext context)
     {
-        DiagnosticHelpers.ReportDiagnostic(context, DiagnosticRules.UseImplicitOrExplicitObjectCreation, implicitObjectCreation, "explicit");
+        ImplicitOrExpressionObjectCreationAnalysis.Instance.AnalyzeCollectionExpression(ref context);
     }
 }
diff --git a/src/Analyzers/CSharp/DiagnosticRules.Generated.cs b/src/Analyzers/CSharp/DiagnosticRules.Generated.cs
index 1f89365233..87ec5b2cb7 100644
--- a/src/Analyzers/CSharp/DiagnosticRules.Generated.cs
+++ b/src/Analyzers/CSharp/DiagnosticRules.Generated.cs
@@ -165,7 +165,7 @@ public static partial class DiagnosticRules
         public static readonly DiagnosticDescriptor UseExplicitlyOrImplicitlyTypedArray = DiagnosticDescriptorFactory.Create(
             id:                 DiagnosticIdentifiers.UseExplicitlyOrImplicitlyTypedArray, 
             title:              "Use explicitly/implicitly typed array", 
-            messageFormat:      "Use {0} typed array", 
+            messageFormat:      "{0}", 
             category:           DiagnosticCategories.Roslynator, 
             defaultSeverity:    DiagnosticSeverity.Info, 
             isEnabledByDefault: false, 
@@ -2439,7 +2439,7 @@ public static partial class DiagnosticRules
         public static readonly DiagnosticDescriptor UseImplicitOrExplicitObjectCreation = DiagnosticDescriptorFactory.Create(
             id:                 DiagnosticIdentifiers.UseImplicitOrExplicitObjectCreation, 
             title:              "Use implicit/explicit object creation", 
-            messageFormat:      "Use {0} object creation", 
+            messageFormat:      "{0}", 
             category:           DiagnosticCategories.Roslynator, 
             defaultSeverity:    DiagnosticSeverity.Info, 
             isEnabledByDefault: false, 
diff --git a/src/CSharp/CSharp/CSharpTypeAnalysis.cs b/src/CSharp/CSharp/CSharpTypeAnalysis.cs
index 03e603bf01..2ea480bfb0 100644
--- a/src/CSharp/CSharp/CSharpTypeAnalysis.cs
+++ b/src/CSharp/CSharp/CSharpTypeAnalysis.cs
@@ -39,6 +39,9 @@ public static TypeAnalysis AnalyzeType(
         if (expression is null)
             return default;
 
+        if (expression.IsKind(SyntaxKind.CollectionExpression))
+            return default;
+
         ITypeSymbol? typeSymbol = semanticModel.GetTypeSymbol(type, cancellationToken);
 
         if (typeSymbol is null)
@@ -222,8 +225,14 @@ public static bool IsExplicitThatCanBeImplicit(
         if (expression is null)
             return false;
 
-        if (expression.IsKind(SyntaxKind.NullLiteralExpression, SyntaxKind.DefaultLiteralExpression, SyntaxKind.ImplicitObjectCreationExpression))
+        if (expression.IsKind(
+            SyntaxKind.NullLiteralExpression,
+            SyntaxKind.DefaultLiteralExpression,
+            SyntaxKind.ImplicitObjectCreationExpression,
+            SyntaxKind.CollectionExpression))
+        {
             return false;
+        }
 
         if (expression.IsKind(SyntaxKind.SuppressNullableWarningExpression)
             && expression is PostfixUnaryExpressionSyntax postfixUnary
diff --git a/src/CSharp/CSharp/CSharpUtility.cs b/src/CSharp/CSharp/CSharpUtility.cs
index b7dc184c25..b8d61636e9 100644
--- a/src/CSharp/CSharp/CSharpUtility.cs
+++ b/src/CSharp/CSharp/CSharpUtility.cs
@@ -10,6 +10,56 @@ namespace Roslynator.CSharp;
 
 internal static class CSharpUtility
 {
+    //public static bool CanConvertToCollectionExpression(ImplicitObjectCreationExpressionSyntax implicitObjectCreation, SemanticModel semanticModel, CancellationToken cancellationToken)
+    //{
+    //    return !implicitObjectCreation.WalkUpParentheses().IsParentKind(SyntaxKind.Argument)
+    //        && implicitObjectCreation.ArgumentList?.Arguments.Any() != true
+    //        && SyntaxUtility.CanConvertToCollectionExpression(implicitObjectCreation, semanticModel, cancellationToken);
+    //}
+
+    //public static bool CanConvertToCollectionExpression(ObjectCreationExpressionSyntax objectCreation, SemanticModel semanticModel, CancellationToken cancellationToken)
+    //{
+    //    return !objectCreation.WalkUpParentheses().IsParentKind(SyntaxKind.Argument)
+    //        && objectCreation.ArgumentList?.Arguments.Any() != true
+    //        && SyntaxUtility.CanConvertToCollectionExpression(objectCreation, semanticModel, cancellationToken);
+    //}
+
+    //public static bool CanConvertToCollectionExpression(ArrayCreationExpressionSyntax arrayCreation, SemanticModel semanticModel, CancellationToken cancellationToken)
+    //{
+    //    return CanConvertToCollectionExpression(arrayCreation)
+    //        && SyntaxUtility.CanConvertToCollectionExpression(arrayCreation, semanticModel, cancellationToken);
+    //}
+
+    //public static bool CanConvertToCollectionExpression(ImplicitArrayCreationExpressionSyntax implicitArrayCreation, SemanticModel semanticModel, CancellationToken cancellationToken)
+    //{
+    //    CSharpTypeAnalysis.IsTypeObvious(implicitArrayCreation, semanticModel, cancellationToken);
+    //    return CanConvertToCollectionExpression(implicitArrayCreation)
+    //        && SyntaxUtility.CanConvertToCollectionExpression(implicitArrayCreation, semanticModel, cancellationToken);
+    //}
+
+    //private static bool CanConvertToCollectionExpression(ExpressionSyntax expression)
+    //{
+    //    expression = expression.WalkUpParentheses();
+
+    //    if (expression.IsParentKind(
+    //        SyntaxKind.Argument,
+    //        SyntaxKind.ForEachStatement,
+    //        SyntaxKind.ForEachVariableStatement))
+    //    {
+    //        return false;
+    //    }
+
+    //    if (expression.Parent.IsKind(SyntaxKind.EqualsValueClause)
+    //        && expression.Parent.Parent.IsKind(SyntaxKind.VariableDeclarator)
+    //        && expression.Parent.Parent.Parent is VariableDeclarationSyntax variableDeclaration
+    //        && variableDeclaration.Type.IsVar)
+    //    {
+    //        return false;
+    //    }
+
+    //    return true;
+    //}
+
     public static bool IsNullableReferenceType(
         TypeSyntax type,
         SemanticModel semanticModel,
diff --git a/src/CSharp/CSharp/Extensions/SyntaxExtensions.cs b/src/CSharp/CSharp/Extensions/SyntaxExtensions.cs
index 8a1f927424..591cefa6ad 100644
--- a/src/CSharp/CSharp/Extensions/SyntaxExtensions.cs
+++ b/src/CSharp/CSharp/Extensions/SyntaxExtensions.cs
@@ -1858,6 +1858,38 @@ internal static int IndexOf(this SeparatedSyntaxList<TypeParameterSyntax> typePa
 
         return -1;
     }
+
+    //TODO: make public
+    internal static SeparatedSyntaxList<TResult> ForEach<TSource, TResult>(this SeparatedSyntaxList<TSource> list, Func<TSource, TResult> selector)
+        where TSource : SyntaxNode
+        where TResult : SyntaxNode
+    {
+        int count = list.Count + list.SeparatorCount;
+        var items = new List<SyntaxNodeOrToken>(count);
+
+        int i = 0;
+        while (i < count)
+        {
+            items.Add(default);
+            i++;
+        }
+
+        i = 0;
+        while (i < list.Count)
+        {
+            items[i * 2] = selector(list[i]);
+            i++;
+        }
+
+        i = 0;
+        foreach (SyntaxToken separator in list.GetSeparators())
+        {
+            items[(i * 2) + 1] = separator;
+            i++;
+        }
+
+        return SeparatedList<TResult>(items);
+    }
     #endregion SeparatedSyntaxList<T>
 
     #region StatementSyntax
diff --git a/src/CSharp/CSharp/SyntaxRefactorings.cs b/src/CSharp/CSharp/SyntaxRefactorings.cs
index 3f22662191..e92242db3d 100644
--- a/src/CSharp/CSharp/SyntaxRefactorings.cs
+++ b/src/CSharp/CSharp/SyntaxRefactorings.cs
@@ -815,4 +815,34 @@ public static BinaryExpressionSyntax SwapBinaryOperands(BinaryExpressionSyntax b
             operatorToken: Token(token.LeadingTrivia, newTokenKind, token.TrailingTrivia),
             right: left.WithTriviaFrom(right));
     }
+
+    public static CollectionExpressionSyntax ConvertInitializerToCollectionExpression(InitializerExpressionSyntax? initializer)
+    {
+        if (initializer is not null)
+        {
+            return CollectionExpression(
+                Token(SyntaxKind.OpenBracketToken).WithTriviaFrom(initializer.OpenBraceToken),
+                initializer.Expressions.ForEach(e => (CollectionElementSyntax)ExpressionElement(e)),
+                Token(SyntaxKind.CloseBracketToken).WithTriviaFrom(initializer.CloseBraceToken));
+        }
+        else
+        {
+            return CollectionExpression();
+        }
+    }
+
+    public static InitializerExpressionSyntax? ConvertCollectionExpressionToInitializer(CollectionExpressionSyntax collectionExpression, SyntaxKind initializerKind)
+    {
+        if (collectionExpression.Elements.Any())
+        {
+            return InitializerExpression(
+                initializerKind,
+                collectionExpression
+                    .Elements
+                    .Select(element => ((ExpressionElementSyntax)element).Expression)
+                    .ToSeparatedSyntaxList());
+        }
+
+        return default;
+    }
 }
diff --git a/src/CSharp/CSharp/SyntaxWalkers/CSharpSyntaxNodeWalker.cs b/src/CSharp/CSharp/SyntaxWalkers/CSharpSyntaxNodeWalker.cs
index dd7acb4755..0e9f6767a0 100644
--- a/src/CSharp/CSharp/SyntaxWalkers/CSharpSyntaxNodeWalker.cs
+++ b/src/CSharp/CSharp/SyntaxWalkers/CSharpSyntaxNodeWalker.cs
@@ -737,6 +737,19 @@ public override void VisitClassOrStructConstraint(ClassOrStructConstraintSyntax
         {
         }
 
+        public override void VisitCollectionExpression(CollectionExpressionSyntax node)
+        {
+            foreach (CollectionElementSyntax collectionElement in node.Elements)
+            {
+                if (!ShouldVisit)
+                {
+                    return;
+                }
+
+                VisitCollectionElement(collectionElement);
+            }
+        }
+
         public override void VisitCompilationUnit(CompilationUnitSyntax node)
         {
             foreach (ExternAliasDirectiveSyntax externAliasDirective in node.Externs)
@@ -1548,6 +1561,20 @@ public override void VisitExpressionColon(ExpressionColonSyntax node)
             }
         }
 
+        public override void VisitExpressionElement(ExpressionElementSyntax node)
+        {
+            if (!ShouldVisit)
+            {
+                return;
+            }
+
+            ExpressionSyntax expression = node.Expression;
+            if (expression != null)
+            {
+                VisitExpression(expression);
+            }
+        }
+
         public override void VisitExpressionStatement(ExpressionStatementSyntax node)
         {
             if (!ShouldVisit)
@@ -3943,6 +3970,20 @@ public override void VisitSlicePattern(SlicePatternSyntax node)
         {
         }
 
+        public override void VisitSpreadElement(SpreadElementSyntax node)
+        {
+            if (!ShouldVisit)
+            {
+                return;
+            }
+
+            ExpressionSyntax expression = node.Expression;
+            if (expression != null)
+            {
+                VisitExpression(expression);
+            }
+        }
+
         public override void VisitStackAllocArrayCreationExpression(StackAllocArrayCreationExpressionSyntax node)
         {
             if (!ShouldVisit)
@@ -5001,6 +5042,9 @@ protected virtual void VisitExpression(ExpressionSyntax node)
                 case SyntaxKind.CastExpression:
                     VisitCastExpression((CastExpressionSyntax)node);
                     break;
+                case SyntaxKind.CollectionExpression:
+                    VisitCollectionExpression((CollectionExpressionSyntax)node);
+                    break;
                 case SyntaxKind.ConditionalAccessExpression:
                     VisitConditionalAccessExpression((ConditionalAccessExpressionSyntax)node);
                     break;
@@ -5657,5 +5701,22 @@ protected virtual void VisitXmlNode(XmlNodeSyntax node)
                     break;
             }
         }
+
+        protected virtual void VisitCollectionElement(CollectionElementSyntax node)
+        {
+            switch (node.Kind())
+            {
+                case SyntaxKind.ExpressionElement:
+                    VisitExpressionElement((ExpressionElementSyntax)node);
+                    break;
+                case SyntaxKind.SpreadElement:
+                    VisitSpreadElement((SpreadElementSyntax)node);
+                    break;
+                default:
+                    Debug.Fail($"Unrecognized kind '{node.Kind()}'.");
+                    base.Visit(node);
+                    break;
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/src/CodeAnalysis.Analyzers.CodeFixes/Roslynator.CodeAnalysis.Analyzers.nuspec b/src/CodeAnalysis.Analyzers.CodeFixes/Roslynator.CodeAnalysis.Analyzers.nuspec
index 2ac86fbd61..f35e05336b 100644
--- a/src/CodeAnalysis.Analyzers.CodeFixes/Roslynator.CodeAnalysis.Analyzers.nuspec
+++ b/src/CodeAnalysis.Analyzers.CodeFixes/Roslynator.CodeAnalysis.Analyzers.nuspec
@@ -11,7 +11,7 @@
     <requireLicenseAcceptance>false</requireLicenseAcceptance>
     <description>A collection of analyzers for Roslyn API.
 
-  - This package is dependent on Microsoft.CodeAnalysis.CSharp.Workspaces 4.6.0.
+  - This package is dependent on Microsoft.CodeAnalysis.CSharp.Workspaces 4.7.0.
   - This package is applicable for projects that reference Roslyn packages (Microsoft.CodeAnalysis*).</description>
     <summary>A collection of analyzers for Roslyn API.</summary>
     <copyright>Copyright (c) 2016-2023 Josef Pihrt</copyright>
diff --git a/src/Common/CSharp/Analysis/DiagnosticPropertyKeys.cs b/src/Common/CSharp/Analysis/DiagnosticPropertyKeys.cs
new file mode 100644
index 0000000000..836d2eadac
--- /dev/null
+++ b/src/Common/CSharp/Analysis/DiagnosticPropertyKeys.cs
@@ -0,0 +1,10 @@
+// Copyright (c) .NET Foundation and Contributors. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespace Roslynator.CSharp.Analysis;
+
+internal static class DiagnosticPropertyKeys
+{
+    internal static readonly string ImplicitToCollectionExpression = nameof(ImplicitToCollectionExpression);
+    internal static readonly string CollectionExpressionToImplicit = nameof(CollectionExpressionToImplicit);
+    internal static readonly string ExplicitToCollectionExpression = nameof(ExplicitToCollectionExpression);
+}
diff --git a/src/Common/CSharp/CodeStyle/ObjectCreationTypeStyle.cs b/src/Common/CSharp/CodeStyle/ObjectCreationTypeStyle.cs
deleted file mode 100644
index ce08085374..0000000000
--- a/src/Common/CSharp/CodeStyle/ObjectCreationTypeStyle.cs
+++ /dev/null
@@ -1,11 +0,0 @@
-// Copyright (c) .NET Foundation and Contributors. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
-
-namespace Roslynator.CSharp.CodeStyle;
-
-internal enum ObjectCreationTypeStyle
-{
-    None,
-    Explicit,
-    Implicit,
-    ImplicitWhenTypeIsObvious,
-}
diff --git a/src/Common/CSharp/CodeStyle/ArrayCreationTypeStyle.cs b/src/Common/CSharp/CodeStyle/TypeStyle.cs
similarity index 88%
rename from src/Common/CSharp/CodeStyle/ArrayCreationTypeStyle.cs
rename to src/Common/CSharp/CodeStyle/TypeStyle.cs
index 4a40de779e..2c890cafae 100644
--- a/src/Common/CSharp/CodeStyle/ArrayCreationTypeStyle.cs
+++ b/src/Common/CSharp/CodeStyle/TypeStyle.cs
@@ -2,7 +2,7 @@
 
 namespace Roslynator.CSharp.CodeStyle;
 
-internal enum ArrayCreationTypeStyle
+internal enum TypeStyle
 {
     None,
     Explicit,
diff --git a/src/Common/CSharp/Extensions/CodeStyleExtensions.cs b/src/Common/CSharp/Extensions/CodeStyleExtensions.cs
index 09976982e9..97f07577d9 100644
--- a/src/Common/CSharp/Extensions/CodeStyleExtensions.cs
+++ b/src/Common/CSharp/Extensions/CodeStyleExtensions.cs
@@ -422,7 +422,7 @@ public static TrailingCommaStyle GetTrailingCommaStyle(this SyntaxNodeAnalysisCo
         return TrailingCommaStyle.None;
     }
 
-    public static ObjectCreationTypeStyle GetObjectCreationTypeStyle(this SyntaxNodeAnalysisContext context)
+    public static TypeStyle GetObjectCreationTypeStyle(this SyntaxNodeAnalysisContext context)
     {
         AnalyzerConfigOptions configOptions = context.GetConfigOptions();
 
@@ -430,22 +430,32 @@ public static ObjectCreationTypeStyle GetObjectCreationTypeStyle(this SyntaxNode
         {
             if (string.Equals(rawValue, ConfigOptionValues.ObjectCreationTypeStyle_Implicit, StringComparison.OrdinalIgnoreCase))
             {
-                return ObjectCreationTypeStyle.Implicit;
+                return TypeStyle.Implicit;
             }
             else if (string.Equals(rawValue, ConfigOptionValues.ObjectCreationTypeStyle_Explicit, StringComparison.OrdinalIgnoreCase))
             {
-                return ObjectCreationTypeStyle.Explicit;
+                return TypeStyle.Explicit;
             }
             else if (string.Equals(rawValue, ConfigOptionValues.ObjectCreationTypeStyle_ImplicitWhenTypeIsObvious, StringComparison.OrdinalIgnoreCase))
             {
-                return ObjectCreationTypeStyle.ImplicitWhenTypeIsObvious;
+                return TypeStyle.ImplicitWhenTypeIsObvious;
             }
         }
 
-        return ObjectCreationTypeStyle.None;
+        return TypeStyle.None;
     }
 
-    public static ArrayCreationTypeStyle GetArrayCreationTypeStyle(this SyntaxNodeAnalysisContext context)
+    public static bool? UseCollectionExpression(this SyntaxNodeAnalysisContext context)
+    {
+        return UseCollectionExpression(context.GetConfigOptions());
+    }
+
+    public static bool? UseCollectionExpression(this AnalyzerConfigOptions configOptions)
+    {
+        return ConfigOptions.GetValueAsBool(configOptions, ConfigOptions.UseCollectionExpression);
+    }
+
+    public static TypeStyle GetArrayCreationTypeStyle(this SyntaxNodeAnalysisContext context)
     {
         AnalyzerConfigOptions configOptions = context.GetConfigOptions();
 
@@ -453,25 +463,25 @@ public static ArrayCreationTypeStyle GetArrayCreationTypeStyle(this SyntaxNodeAn
         {
             if (string.Equals(rawValue, ConfigOptionValues.ArrayCreationTypeStyle_Implicit, StringComparison.OrdinalIgnoreCase))
             {
-                return ArrayCreationTypeStyle.Implicit;
+                return TypeStyle.Implicit;
             }
             else if (string.Equals(rawValue, ConfigOptionValues.ArrayCreationTypeStyle_Explicit, StringComparison.OrdinalIgnoreCase))
             {
-                return ArrayCreationTypeStyle.Explicit;
+                return TypeStyle.Explicit;
             }
             else if (string.Equals(rawValue, ConfigOptionValues.ArrayCreationTypeStyle_ImplicitWhenTypeIsObvious, StringComparison.OrdinalIgnoreCase))
             {
-                return ArrayCreationTypeStyle.ImplicitWhenTypeIsObvious;
+                return TypeStyle.ImplicitWhenTypeIsObvious;
             }
         }
 
         if (context.IsEnabled(LegacyConfigOptions.UseImplicitlyTypedArrayWhenTypeIsObvious))
-            return ArrayCreationTypeStyle.ImplicitWhenTypeIsObvious;
+            return TypeStyle.ImplicitWhenTypeIsObvious;
 
         if (context.IsEnabled(LegacyConfigOptions.UseImplicitlyTypedArray))
-            return ArrayCreationTypeStyle.Implicit;
+            return TypeStyle.Implicit;
 
-        return ArrayCreationTypeStyle.None;
+        return TypeStyle.None;
     }
 
     public static InfiniteLoopStyle GetInfiniteLoopStyle(this SyntaxNodeAnalysisContext context)
diff --git a/src/Common/CSharp/Extensions/CommonCSharpExtensions.cs b/src/Common/CSharp/Extensions/CommonCSharpExtensions.cs
new file mode 100644
index 0000000000..f960da6dc4
--- /dev/null
+++ b/src/Common/CSharp/Extensions/CommonCSharpExtensions.cs
@@ -0,0 +1,13 @@
+// Copyright (c) .NET Foundation and Contributors. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using Microsoft.CodeAnalysis.CSharp;
+
+namespace Roslynator.CSharp;
+
+internal static class CommonCSharpExtensions
+{
+    public static bool SupportsCollectionExpression(this CSharpCompilation compilation)
+    {
+        return (int)compilation.LanguageVersion >= 1200;
+    }
+}
diff --git a/src/Common/ConfigOptionKeys.Generated.cs b/src/Common/ConfigOptionKeys.Generated.cs
index 765930b719..8c7505c31f 100644
--- a/src/Common/ConfigOptionKeys.Generated.cs
+++ b/src/Common/ConfigOptionKeys.Generated.cs
@@ -42,6 +42,7 @@ internal static partial class ConfigOptionKeys
         public const string UseAnonymousFunctionOrMethodGroup                 = "roslynator_use_anonymous_function_or_method_group";
         public const string UseBlockBodyWhenDeclarationSpansOverMultipleLines = "roslynator_use_block_body_when_declaration_spans_over_multiple_lines";
         public const string UseBlockBodyWhenExpressionSpansOverMultipleLines  = "roslynator_use_block_body_when_expression_spans_over_multiple_lines";
+        public const string UseCollectionExpression                           = "roslynator_use_collection_expression";
         public const string UseVarInsteadOfImplicitObjectCreation             = "roslynator_use_var_instead_of_implicit_object_creation";
     }
 }
\ No newline at end of file
diff --git a/src/Common/ConfigOptions.Generated.cs b/src/Common/ConfigOptions.Generated.cs
index d49aa6f00b..d8dc899a49 100644
--- a/src/Common/ConfigOptions.Generated.cs
+++ b/src/Common/ConfigOptions.Generated.cs
@@ -226,6 +226,12 @@ public static partial class ConfigOptions
             defaultValuePlaceholder: "true|false", 
             description:             "Use block body when expression spans over multiple lines");
 
+        public static readonly ConfigOptionDescriptor UseCollectionExpression = new(
+            key:                     ConfigOptionKeys.UseCollectionExpression, 
+            defaultValue:            null, 
+            defaultValuePlaceholder: "true|false", 
+            description:             "Use collection expression for array/collection creation");
+
         public static readonly ConfigOptionDescriptor UseVarInsteadOfImplicitObjectCreation = new(
             key:                     ConfigOptionKeys.UseVarInsteadOfImplicitObjectCreation, 
             defaultValue:            null, 
diff --git a/src/Common/RoslynMetadataNames.cs b/src/Common/RoslynMetadataNames.cs
index 08e3d0c1d5..6931baec00 100644
--- a/src/Common/RoslynMetadataNames.cs
+++ b/src/Common/RoslynMetadataNames.cs
@@ -31,6 +31,7 @@ internal static class RoslynMetadataNames
     public static readonly MetadataName Microsoft_CodeAnalysis_CSharp_Syntax_VariableDesignationSyntax = MetadataName.Parse("Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax");
     public static readonly MetadataName Microsoft_CodeAnalysis_CSharp_Syntax_XmlAttributeSyntax = MetadataName.Parse("Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax");
     public static readonly MetadataName Microsoft_CodeAnalysis_CSharp_Syntax_XmlNodeSyntax = MetadataName.Parse("Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax");
+    public static readonly MetadataName Microsoft_CodeAnalysis_CSharp_Syntax_CollectionElementSyntax = MetadataName.Parse("Microsoft.CodeAnalysis.CSharp.Syntax.CollectionElementSyntax");
     public static readonly MetadataName Microsoft_CodeAnalysis_CSharp_SyntaxKind = MetadataName.Parse("Microsoft.CodeAnalysis.CSharp.SyntaxKind");
     public static readonly MetadataName Microsoft_CodeAnalysis_CSharpExtensions = MetadataName.Parse("Microsoft.CodeAnalysis.CSharpExtensions");
     public static readonly MetadataName Microsoft_CodeAnalysis_Diagnostics = MetadataName.Parse("Microsoft.CodeAnalysis.Diagnostics");
diff --git a/src/ConfigOptions.xml b/src/ConfigOptions.xml
index 2b416e5a23..44aa41017e 100644
--- a/src/ConfigOptions.xml
+++ b/src/ConfigOptions.xml
@@ -225,6 +225,10 @@
       <Value>omit_after_block</Value>
     </Values>
   </Option>
+  <Option Id="UseCollectionExpression">
+    <ValuePlaceholder>true|false</ValuePlaceholder>
+    <Description>Use collection expression for array/collection creation</Description>
+  </Option>
   <!--
   <Option Id="">
     <Key></Key>
diff --git a/src/Core/MetadataNames.cs b/src/Core/MetadataNames.cs
index 03949d2f85..4c35e78590 100644
--- a/src/Core/MetadataNames.cs
+++ b/src/Core/MetadataNames.cs
@@ -47,8 +47,10 @@ internal static class MetadataNames
     public static readonly MetadataName System_Linq_IQueryable_T = MetadataName.Parse("System.Linq.IQueryable`1");
     public static readonly MetadataName System_NonSerializedAttribute = MetadataName.Parse("System.NonSerializedAttribute");
     public static readonly MetadataName System_ObsoleteAttribute = MetadataName.Parse("System.ObsoleteAttribute");
+    public static readonly MetadataName System_ReadOnlySpan_T = MetadataName.Parse("System.ReadOnlySpan`1");
     public static readonly MetadataName System_Reflection = MetadataName.Parse("System.Reflection");
     public static readonly MetadataName System_Runtime_CompilerServices = MetadataName.Parse("System.Runtime.CompilerServices");
+    public static readonly MetadataName System_Runtime_CompilerServices_CollectionBuilderAttribute = MetadataName.Parse("System.Runtime.CompilerServices.CollectionBuilderAttribute");
     public static readonly MetadataName System_Runtime_CompilerServices_ConfiguredTaskAwaitable = MetadataName.Parse("System.Runtime.CompilerServices.ConfiguredTaskAwaitable");
     public static readonly MetadataName System_Runtime_CompilerServices_ConfiguredTaskAwaitable_T = MetadataName.Parse("System.Runtime.CompilerServices.ConfiguredTaskAwaitable`1");
     public static readonly MetadataName System_Runtime_InteropServices_LayoutKind = MetadataName.Parse("System.Runtime.InteropServices.LayoutKind");
diff --git a/src/Core/SyntaxUtility.cs b/src/Core/SyntaxUtility.cs
index 8849709377..7d75216431 100644
--- a/src/Core/SyntaxUtility.cs
+++ b/src/Core/SyntaxUtility.cs
@@ -1,5 +1,6 @@
 // Copyright (c) .NET Foundation and Contributors. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
+using System.Linq;
 using System.Threading;
 using Microsoft.CodeAnalysis;
 
@@ -7,6 +8,45 @@ namespace Roslynator;
 
 internal static class SyntaxUtility
 {
+    public static bool CanConvertToCollectionExpression(SyntaxNode node, SemanticModel semanticModel, CancellationToken cancellationToken)
+    {
+        TypeInfo typeInfo = semanticModel.GetTypeInfo(node, cancellationToken);
+
+        if (typeInfo.ConvertedType?.SpecialType == SpecialType.System_Object)
+            return false;
+
+        ITypeSymbol? typeSymbol = typeInfo.Type;
+
+        if (typeSymbol?.IsErrorType() != false)
+            return false;
+
+        if (typeSymbol is IArrayTypeSymbol arrayType)
+            return arrayType.Rank == 1;
+
+        if (typeSymbol.HasMetadataName(MetadataNames.System_Span_T)
+            || typeSymbol.HasMetadataName(MetadataNames.System_ReadOnlySpan_T)
+            || typeSymbol.HasAttribute(MetadataNames.System_Runtime_CompilerServices_CollectionBuilderAttribute))
+        {
+            return true;
+        }
+
+        if (typeSymbol is INamedTypeSymbol namedType
+            && namedType.ImplementsAny(
+                SpecialType.System_Collections_IEnumerable,
+                SpecialType.System_Collections_Generic_IEnumerable_T,
+                allInterfaces: true))
+        {
+            IMethodSymbol? constructor = namedType
+                .InstanceConstructors
+                .SingleOrDefault(f => !f.Parameters.Any(), shouldThrow: false);
+
+            return constructor is not null
+                && semanticModel.IsAccessible(node.SpanStart, constructor);
+        }
+
+        return false;
+    }
+
     public static bool IsPropertyOfNullableOfT(
         SyntaxNode node,
         string name,
diff --git a/src/Directory.Build.props b/src/Directory.Build.props
index f07394885c..c70b1f9824 100644
--- a/src/Directory.Build.props
+++ b/src/Directory.Build.props
@@ -14,7 +14,7 @@
   <PropertyGroup>
     <Version Condition="'$(Version)' == ''">1.0.0</Version>
     <!-- Update version in nuspec description when updating 'RoslynatorRoslynVersion' -->
-    <RoslynatorRoslynVersion>4.6.0</RoslynatorRoslynVersion>
+    <RoslynatorRoslynVersion>4.7.0</RoslynatorRoslynVersion>
     <RoslynatorRoslynAnalyzersVersion>3.3.4</RoslynatorRoslynAnalyzersVersion>
     <RoslynatorCliRoslynVersion>4.8.0</RoslynatorCliRoslynVersion>
     <RoslynatorTestingRoslynVersion>4.8.0</RoslynatorTestingRoslynVersion>
diff --git a/src/Formatting.Analyzers.CodeFixes/Roslynator.Formatting.Analyzers.nuspec b/src/Formatting.Analyzers.CodeFixes/Roslynator.Formatting.Analyzers.nuspec
index c4c34645fd..632b6aa5fb 100644
--- a/src/Formatting.Analyzers.CodeFixes/Roslynator.Formatting.Analyzers.nuspec
+++ b/src/Formatting.Analyzers.CodeFixes/Roslynator.Formatting.Analyzers.nuspec
@@ -11,7 +11,7 @@
     <requireLicenseAcceptance>false</requireLicenseAcceptance>
     <description>A collection of formatting analyzers, powered by Roslyn.
 
-  - This package is dependent on Microsoft.CodeAnalysis.CSharp.Workspaces 4.6.0.
+  - This package is dependent on Microsoft.CodeAnalysis.CSharp.Workspaces 4.7.0.
   - All analyzers are disabled by default.</description>
     <summary>A collection of formatting analyzers, powered by Roslyn.</summary>
     <copyright>Copyright (c) 2016-2023 Josef Pihrt</copyright>
diff --git a/src/Formatting.Analyzers/CSharp/PutEmbeddedStatementOnItsOwnLineAnalyzer.cs b/src/Formatting.Analyzers/CSharp/PutEmbeddedStatementOnItsOwnLineAnalyzer.cs
index c6d1232f80..0f0fd4a26a 100644
--- a/src/Formatting.Analyzers/CSharp/PutEmbeddedStatementOnItsOwnLineAnalyzer.cs
+++ b/src/Formatting.Analyzers/CSharp/PutEmbeddedStatementOnItsOwnLineAnalyzer.cs
@@ -99,6 +99,9 @@ internal static void AnalyzeFixedStatement(SyntaxNodeAnalysisContext context)
 
     private static void Analyze(SyntaxNodeAnalysisContext context, SyntaxToken token, StatementSyntax statement)
     {
+        if (statement.IsMissing)
+            return;
+
         TriviaBlock block = TriviaBlock.FromBetween(token, statement);
 
         if (block.Kind == TriviaBlockKind.NoNewLine)
diff --git a/src/Tests/Analyzers.Tests/RCS1014UseExplicitlyTypedArrayOrViceVersaTests.cs b/src/Tests/Analyzers.Tests/RCS1014UseExplicitlyTypedArrayOrViceVersaTests.cs
index 37711b3203..8543630200 100644
--- a/src/Tests/Analyzers.Tests/RCS1014UseExplicitlyTypedArrayOrViceVersaTests.cs
+++ b/src/Tests/Analyzers.Tests/RCS1014UseExplicitlyTypedArrayOrViceVersaTests.cs
@@ -34,6 +34,39 @@ void M()
 ", options: Options.AddConfigOption(ConfigOptionKeys.ArrayCreationTypeStyle, ConfigOptionValues.ArrayCreationTypeStyle_Explicit));
     }
 
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseExplicitlyOrImplicitlyTypedArray)]
+    public async Task Test_TypeIsObvious()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+class C
+{
+    private object[] f = new [|string|][] { string.Empty };
+}
+", @"
+class C
+{
+    private object[] f = new[] { string.Empty };
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ArrayCreationTypeStyle, ConfigOptionValues.ArrayCreationTypeStyle_ImplicitWhenTypeIsObvious));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseExplicitlyOrImplicitlyTypedArray)]
+    public async Task Test_TypeIsObvious_ToCollectionExpression()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+class C
+{
+    private object[] f = new [|string|][] { string.Empty };
+}
+", @"
+class C
+{
+    private object[] f = [string.Empty];
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ArrayCreationTypeStyle, ConfigOptionValues.ArrayCreationTypeStyle_ImplicitWhenTypeIsObvious)
+            .AddConfigOption(ConfigOptionKeys.UseCollectionExpression, true));
+    }
+
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseExplicitlyOrImplicitlyTypedArray)]
     public async Task Test_TypeIsNotObvious()
     {
@@ -192,6 +225,282 @@ void M()
         var items = new string[0];
     }
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.ArrayCreationTypeStyle, ConfigOptionValues.AccessibilityModifiers_Implicit));
+", options: Options.AddConfigOption(ConfigOptionKeys.ArrayCreationTypeStyle, ConfigOptionValues.ArrayCreationTypeStyle_Implicit));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseExplicitlyOrImplicitlyTypedArray)]
+    public async Task TestNoDiagnostic_AssignmentToObject()
+    {
+        await VerifyNoDiagnosticAsync(@"
+class C
+{
+    void M()
+    {
+        object o = new[] { "", "" };
+    }
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ArrayCreationTypeStyle, ConfigOptionValues.ArrayCreationTypeStyle_Implicit)
+            .AddConfigOption(ConfigOptionKeys.UseCollectionExpression, true));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseExplicitlyOrImplicitlyTypedArray)]
+    public async Task TestNoDiagnostic_ForEachExpression()
+    {
+        await VerifyNoDiagnosticAsync(@"
+class C
+{
+    void M()
+    {
+        foreach (string item in new[] { "", "" })
+        {
+        }
+    }
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ArrayCreationTypeStyle, ConfigOptionValues.ArrayCreationTypeStyle_Implicit)
+            .AddConfigOption(ConfigOptionKeys.UseCollectionExpression, true));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseExplicitlyOrImplicitlyTypedArray)]
+    public async Task Test_ExplicitToCollectionExpression_ImplicitStyle()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+class C
+{
+    void M(string[] arr)
+    {
+        arr = new [|string|][] { """" };
+    }
+}
+", @"
+class C
+{
+    void M(string[] arr)
+    {
+        arr = [""""];
+    }
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ArrayCreationTypeStyle, ConfigOptionValues.ArrayCreationTypeStyle_Implicit)
+            .AddConfigOption(ConfigOptionKeys.UseCollectionExpression, true));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseExplicitlyOrImplicitlyTypedArray)]
+    public async Task Test_ExplicitToCollectionExpression_ImplicitStyle_WithComments()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+class C
+{
+    void M(string[] arr)
+    {
+        arr = new [|string|][]
+        {
+            """", // a
+            string.Empty // b
+        };
+    }
+}
+", @"
+class C
+{
+    void M(string[] arr)
+    {
+        arr = [
+            """", // a
+            string.Empty // b
+        ];
+    }
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ArrayCreationTypeStyle, ConfigOptionValues.ArrayCreationTypeStyle_Implicit)
+            .AddConfigOption(ConfigOptionKeys.UseCollectionExpression, true));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseExplicitlyOrImplicitlyTypedArray)]
+    public async Task Test_ExplicitToCollectionExpression_ImplicitWhenObviousStyle()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+class C
+{
+    string[] P { get; } = new [|string|][] { """" };
+}
+", @"
+class C
+{
+    string[] P { get; } = [""""];
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ArrayCreationTypeStyle, ConfigOptionValues.ArrayCreationTypeStyle_ImplicitWhenTypeIsObvious)
+            .AddConfigOption(ConfigOptionKeys.UseCollectionExpression, true));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseExplicitlyOrImplicitlyTypedArray)]
+    public async Task Test_ImplicitToCollectionExpression_ImplicitStyle()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+class C
+{
+    void M(string[] arr)
+    {
+        arr = [|new[]|] { """" };
+    }
+}
+", @"
+class C
+{
+    void M(string[] arr)
+    {
+        arr = [""""];
+    }
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ArrayCreationTypeStyle, ConfigOptionValues.ArrayCreationTypeStyle_Implicit)
+            .AddConfigOption(ConfigOptionKeys.UseCollectionExpression, true));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseExplicitlyOrImplicitlyTypedArray)]
+    public async Task Test_ImplicitToCollectionExpression_ImplicitWhenObviousStyle()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+class C
+{
+    string[] P { get; } = [|new[]|] { """" };
+}
+", @"
+class C
+{
+    string[] P { get; } = [""""];
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ArrayCreationTypeStyle, ConfigOptionValues.ArrayCreationTypeStyle_ImplicitWhenTypeIsObvious)
+            .AddConfigOption(ConfigOptionKeys.UseCollectionExpression, true));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseExplicitlyOrImplicitlyTypedArray)]
+    public async Task Test_CollectionExpressionToExplicit_ImplicitStyle()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+class C
+{
+    void M(string[] arr)
+    {
+        arr = [|[""""]|];
+    }
+}
+", @"
+class C
+{
+    void M(string[] arr)
+    {
+        arr = new string[] { """" };
+    }
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ArrayCreationTypeStyle, ConfigOptionValues.ArrayCreationTypeStyle_Explicit));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseExplicitlyOrImplicitlyTypedArray)]
+    public async Task Test_CollectionExpressionToExplicit_ImplicitWhenObviousStyle()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+class C
+{
+    private string _f = """";
+
+    void M(string[] arr)
+    {
+        arr = [|[_f]|];
+    }
+}
+", @"
+class C
+{
+    private string _f = """";
+
+    void M(string[] arr)
+    {
+        arr = new string[] { _f };
+    }
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ArrayCreationTypeStyle, ConfigOptionValues.ArrayCreationTypeStyle_ImplicitWhenTypeIsObvious));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseExplicitlyOrImplicitlyTypedArray)]
+    public async Task Test_CollectionExpressionToImplicit_ImplicitStyle()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+class C
+{
+    void M(string[] arr)
+    {
+        arr = [|[""""]|];
+    }
+}
+", @"
+class C
+{
+    void M(string[] arr)
+    {
+        arr = new[] { """" };
+    }
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ArrayCreationTypeStyle, ConfigOptionValues.ArrayCreationTypeStyle_Implicit)
+            .AddConfigOption(ConfigOptionKeys.UseCollectionExpression, false));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseExplicitlyOrImplicitlyTypedArray)]
+    public async Task Test_CollectionExpressionToImplicit_ImplicitWhenObviousStyle()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+class C
+{
+    string[] P { get; } = [|[""""]|];
+}
+", @"
+class C
+{
+    string[] P { get; } = new[] { """" };
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ArrayCreationTypeStyle, ConfigOptionValues.ArrayCreationTypeStyle_ImplicitWhenTypeIsObvious)
+            .AddConfigOption(ConfigOptionKeys.UseCollectionExpression, false));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseExplicitlyOrImplicitlyTypedArray)]
+    public async Task Test_CollectionExpressionToImplicit_ImplicitWhenObviousStyle2()
+    {
+        await VerifyNoDiagnosticAsync(@"
+class C
+{
+    void M(string p1, object p2)
+    {
+        var nodes = new[] { p1, p2 };
+    }
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ArrayCreationTypeStyle, ConfigOptionValues.ArrayCreationTypeStyle_Implicit)
+            .AddConfigOption(ConfigOptionKeys.UseCollectionExpression, true));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseExplicitlyOrImplicitlyTypedArray)]
+    public async Task Test_CollectionExpressionToExplicit_NotArray()
+    {
+        await VerifyNoDiagnosticAsync(@"
+using System.Collections.Generic;
+class C
+{
+    void M(List<string> x)
+    {
+        x = [];
+    }   
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ArrayCreationTypeStyle, ConfigOptionValues.ArrayCreationTypeStyle_Explicit));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseExplicitlyOrImplicitlyTypedArray)]
+    public async Task Test_CollectionExpressionToImplicit_NotArray()
+    {
+        await VerifyNoDiagnosticAsync(@"
+using System.Collections.Generic;
+class C
+{
+    void M(List<string> x)
+    {
+        x = [];
+    }   
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ArrayCreationTypeStyle, ConfigOptionValues.ArrayCreationTypeStyle_Implicit)
+            .AddConfigOption(ConfigOptionKeys.UseCollectionExpression, false));
     }
 }
diff --git a/src/Tests/Analyzers.Tests/RCS1014UseImplicitlyTypedArrayTests.cs b/src/Tests/Analyzers.Tests/RCS1014UseImplicitlyTypedArrayTests.cs
index 5379cbc4f2..13a0436c70 100644
--- a/src/Tests/Analyzers.Tests/RCS1014UseImplicitlyTypedArrayTests.cs
+++ b/src/Tests/Analyzers.Tests/RCS1014UseImplicitlyTypedArrayTests.cs
@@ -114,7 +114,7 @@ public async Task Test_NestedArray()
         await VerifyDiagnosticAndFixAsync(@"
 class C
 {
-    string[][] _f = new [|string[]|][]
+    string[][] _f = new [|string|][][]
     {
         new[] { """" },
     };
@@ -181,4 +181,19 @@ void M()
 }
 ", options: Options.AddConfigOption(ConfigOptionKeys.ArrayCreationTypeStyle, ConfigOptionValues.ArrayCreationTypeStyle_ImplicitWhenTypeIsObvious));
     }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseExplicitlyOrImplicitlyTypedArray)]
+    public async Task TestNoDiagnostic_UseVarInsteadOfObjectCreation()
+    {
+        await VerifyNoDiagnosticAsync(@"
+class C
+{
+    void M()
+    {
+        var items = new string[] { string.Empty };
+    }
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ArrayCreationTypeStyle, ConfigOptionValues.ArrayCreationTypeStyle_Implicit)
+            .AddConfigOption(ConfigOptionKeys.UseVarInsteadOfImplicitObjectCreation, true));
+    }
 }
diff --git a/src/Tests/Analyzers.Tests/RCS1250UseImplicitOrExplicitObjectCreationTests.cs b/src/Tests/Analyzers.Tests/RCS1250UseImplicitOrExplicitObjectCreationTests.cs
index 246b385fdc..6e8251facf 100644
--- a/src/Tests/Analyzers.Tests/RCS1250UseImplicitOrExplicitObjectCreationTests.cs
+++ b/src/Tests/Analyzers.Tests/RCS1250UseImplicitOrExplicitObjectCreationTests.cs
@@ -680,7 +680,7 @@ class C
 {
     string M()
     {
-        return new string(' ', 1);
+        return new(' ', 1);
     }
 }
 ", options: Options.AddConfigOption(ConfigOptionKeys.ObjectCreationTypeStyle, ConfigOptionValues.ObjectCreationTypeStyle_ImplicitWhenTypeIsObvious));
@@ -1600,4 +1600,258 @@ void M()
 }
 ", options: Options.AddConfigOption(ConfigOptionKeys.UseVarInsteadOfImplicitObjectCreation, false));
     }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseImplicitOrExplicitObjectCreation)]
+    public async Task TestNoDiagnostic_ForEachExpression2()
+    {
+        await VerifyNoDiagnosticAsync(@"
+class C
+{
+    string[] M()
+    {
+        return ["""", """"];
+    }
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ObjectCreationTypeStyle, ConfigOptionValues.ObjectCreationTypeStyle_ImplicitWhenTypeIsObvious));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseImplicitOrExplicitObjectCreation)]
+    public async Task Test_ExplicitToCollectionExpression_ImplicitStyle()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+using System.Collections.Generic;
+class C
+{
+    void M(List<string> items)
+    {
+        items = new [|List<string>|]() { """" };
+    }
+}
+", @"
+using System.Collections.Generic;
+class C
+{
+    void M(List<string> items)
+    {
+        items = [""""];
+    }
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ObjectCreationTypeStyle, ConfigOptionValues.ObjectCreationTypeStyle_Implicit)
+            .AddConfigOption(ConfigOptionKeys.UseCollectionExpression, true));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseImplicitOrExplicitObjectCreation)]
+    public async Task Test_ExplicitToCollectionExpression_ImplicitWhenObviousStyle()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+using System.Collections.Generic;
+class C
+{
+    List<string> P { get; } = new [|List<string>|]() { """" };
+}
+", @"
+using System.Collections.Generic;
+class C
+{
+    List<string> P { get; } = [""""];
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ObjectCreationTypeStyle, ConfigOptionValues.ObjectCreationTypeStyle_ImplicitWhenTypeIsObvious)
+            .AddConfigOption(ConfigOptionKeys.UseCollectionExpression, true));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseImplicitOrExplicitObjectCreation)]
+    public async Task Test_ImplicitToCollectionExpression_ImplicitStyle()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+using System.Collections.Generic;
+class C
+{
+    void M(List<string> items)
+    {
+        items = [|new() { """" }|];
+    }
+}
+", @"
+using System.Collections.Generic;
+class C
+{
+    void M(List<string> items)
+    {
+        items = [""""];
+    }
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ObjectCreationTypeStyle, ConfigOptionValues.ObjectCreationTypeStyle_Implicit)
+            .AddConfigOption(ConfigOptionKeys.UseCollectionExpression, true));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseImplicitOrExplicitObjectCreation)]
+    public async Task Test_ImplicitToCollectionExpression_ImplicitWhenObviousStyle()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+using System.Collections.Generic;
+class C
+{
+    List<string> P { get; } = [|new() { """" }|];
+}
+", @"
+using System.Collections.Generic;
+class C
+{
+    List<string> P { get; } = [""""];
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ObjectCreationTypeStyle, ConfigOptionValues.ObjectCreationTypeStyle_ImplicitWhenTypeIsObvious)
+            .AddConfigOption(ConfigOptionKeys.UseCollectionExpression, true));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseImplicitOrExplicitObjectCreation)]
+    public async Task Test_CollectionExpressionToExplicit_ImplicitStyle()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+using System.Collections.Generic;
+class C
+{
+    void M(List<string> items)
+    {
+        items = [|[""""]|];
+    }
+}
+", @"
+using System.Collections.Generic;
+class C
+{
+    void M(List<string> items)
+    {
+        items = new List<string>() { """" };
+    }
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ObjectCreationTypeStyle, ConfigOptionValues.ObjectCreationTypeStyle_Explicit));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseImplicitOrExplicitObjectCreation)]
+    public async Task Test_CollectionExpressionToExplicit_ImplicitWhenObviousStyle()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+using System.Collections.Generic;
+class C
+{
+    private string _f = """";
+
+    void M(List<string> items)
+    {
+        items = [|[_f]|];
+    }
+}
+", @"
+using System.Collections.Generic;
+class C
+{
+    private string _f = """";
+
+    void M(List<string> items)
+    {
+        items = new List<string>() { _f };
+    }
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ObjectCreationTypeStyle, ConfigOptionValues.ObjectCreationTypeStyle_ImplicitWhenTypeIsObvious));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseImplicitOrExplicitObjectCreation)]
+    public async Task Test_CollectionExpressionToImplicit_ImplicitStyle()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+using System.Collections.Generic;
+class C
+{
+    void M(List<string> items)
+    {
+        items = [|[""""]|];
+    }
+}
+", @"
+using System.Collections.Generic;
+class C
+{
+    void M(List<string> items)
+    {
+        items = new() { """" };
+    }
+}
+", options: Options
+            .AddConfigOption(ConfigOptionKeys.ObjectCreationTypeStyle, ConfigOptionValues.ObjectCreationTypeStyle_Implicit)
+            .AddConfigOption(ConfigOptionKeys.UseCollectionExpression, false));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseImplicitOrExplicitObjectCreation)]
+    public async Task Test_CollectionExpressionToImplicit_ImplicitWhenObviousStyle()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+using System.Collections.Generic;
+class C
+{
+    List<string> P { get; } = [|[""""]|];
+}
+", @"
+using System.Collections.Generic;
+class C
+{
+    List<string> P { get; } = new() { """" };
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ObjectCreationTypeStyle, ConfigOptionValues.ObjectCreationTypeStyle_ImplicitWhenTypeIsObvious)
+            .AddConfigOption(ConfigOptionKeys.UseCollectionExpression, false));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseImplicitOrExplicitObjectCreation)]
+    public async Task Test_ExplicitWithParameters()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+using System.Collections.Generic;
+class C : List<string> 
+{
+    C() { }
+    C(string p) { }
+
+    C M()
+    {
+        return new [|C|](""s"");
+    }   
+}
+", @"
+using System.Collections.Generic;
+class C : List<string> 
+{
+    C() { }
+    C(string p) { }
+
+    C M()
+    {
+        return new(""s"");
+    }   
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ObjectCreationTypeStyle, ConfigOptionValues.ObjectCreationTypeStyle_ImplicitWhenTypeIsObvious)
+            .AddConfigOption(ConfigOptionKeys.UseCollectionExpression, true));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseImplicitOrExplicitObjectCreation)]
+    public async Task Test_CollectionExpressionToExplicit()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+using System.Collections.Generic;
+class C
+{
+    void M(List<string> x)
+    {
+        x = [|[]|];
+    }   
+}
+", @"
+using System.Collections.Generic;
+class C
+{
+    void M(List<string> x)
+    {
+        x = new List<string>();
+    }   
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ObjectCreationTypeStyle, ConfigOptionValues.ObjectCreationTypeStyle_Explicit));
+    }
 }
diff --git a/src/Tools/CodeGeneration/CSharp/Symbols.Generated.cs b/src/Tools/CodeGeneration/CSharp/Symbols.Generated.cs
index 5de5318ecc..de2a7d6147 100644
--- a/src/Tools/CodeGeneration/CSharp/Symbols.Generated.cs
+++ b/src/Tools/CodeGeneration/CSharp/Symbols.Generated.cs
@@ -270,6 +270,12 @@ public static IEnumerable<SyntaxKind> GetKinds(INamedTypeSymbol syntaxSymbol)
                     break;
                 }
 
+                case "CollectionExpressionSyntax":
+                {
+                    yield return SyntaxKind.CollectionExpression;
+                    break;
+                }
+
                 case "CompilationUnitSyntax":
                 {
                     yield return SyntaxKind.CompilationUnit;
@@ -518,6 +524,12 @@ public static IEnumerable<SyntaxKind> GetKinds(INamedTypeSymbol syntaxSymbol)
                     break;
                 }
 
+                case "ExpressionElementSyntax":
+                {
+                    yield return SyntaxKind.ExpressionElement;
+                    break;
+                }
+
                 case "ExpressionStatementSyntax":
                 {
                     yield return SyntaxKind.ExpressionStatement;
@@ -1219,6 +1231,12 @@ public static IEnumerable<SyntaxKind> GetKinds(INamedTypeSymbol syntaxSymbol)
                     break;
                 }
 
+                case "SpreadElementSyntax":
+                {
+                    yield return SyntaxKind.SpreadElement;
+                    break;
+                }
+
                 case "StackAllocArrayCreationExpressionSyntax":
                 {
                     yield return SyntaxKind.StackAllocArrayCreationExpression;
diff --git a/src/Tools/CodeGeneration/CSharp/SymbolsGetKindsGenerator.cs b/src/Tools/CodeGeneration/CSharp/SymbolsGetKindsGenerator.cs
index ee79a491c6..51c83a323f 100644
--- a/src/Tools/CodeGeneration/CSharp/SymbolsGetKindsGenerator.cs
+++ b/src/Tools/CodeGeneration/CSharp/SymbolsGetKindsGenerator.cs
@@ -1352,6 +1352,21 @@ static IEnumerable<SyntaxKind> GetSyntaxKinds(INamedTypeSymbol syntaxSymbol)
                             yield return SyntaxKind.ScopedType;
                             break;
                         }
+                    case "CollectionExpressionSyntax":
+                        {
+                            yield return SyntaxKind.CollectionExpression;
+                            break;
+                        }
+                    case "ExpressionElementSyntax":
+                        {
+                            yield return SyntaxKind.ExpressionElement;
+                            break;
+                        }
+                    case "SpreadElementSyntax":
+                        {
+                            yield return SyntaxKind.SpreadElement;
+                            break;
+                        }
                     default:
                         {
                             throw new InvalidOperationException(syntaxSymbol.Name);
diff --git a/src/Tools/CodeGeneration/CSharp/SyntaxWalker/CSharpSyntaxWalkerGenerator.Generated.cs b/src/Tools/CodeGeneration/CSharp/SyntaxWalker/CSharpSyntaxWalkerGenerator.Generated.cs
index e2dc9675bf..efa24901b9 100644
--- a/src/Tools/CodeGeneration/CSharp/SyntaxWalker/CSharpSyntaxWalkerGenerator.Generated.cs
+++ b/src/Tools/CodeGeneration/CSharp/SyntaxWalker/CSharpSyntaxWalkerGenerator.Generated.cs
@@ -3377,6 +3377,42 @@ protected virtual bool ShouldVisit(IPropertySymbol propertySymbol)
                     }
                 }
 
+                case "CollectionExpressionSyntax":
+                {
+                    switch (propertySymbol.Name)
+                    {
+                        case "OpenBracketToken":
+                        case "Elements":
+                        case "CloseBracketToken":
+                            return true;
+                        default:
+                            throw new InvalidOperationException($"Unrecognized property '{propertySymbol.ToDisplayString(SymbolDisplayFormats.Test)}'");
+                    }
+                }
+
+                case "ExpressionElementSyntax":
+                {
+                    switch (propertySymbol.Name)
+                    {
+                        case "Expression":
+                            return true;
+                        default:
+                            throw new InvalidOperationException($"Unrecognized property '{propertySymbol.ToDisplayString(SymbolDisplayFormats.Test)}'");
+                    }
+                }
+
+                case "SpreadElementSyntax":
+                {
+                    switch (propertySymbol.Name)
+                    {
+                        case "OperatorToken":
+                        case "Expression":
+                            return true;
+                        default:
+                            throw new InvalidOperationException($"Unrecognized property '{propertySymbol.ToDisplayString(SymbolDisplayFormats.Test)}'");
+                    }
+                }
+
                 default:
                 {
                     throw new InvalidOperationException($"Unrecognized type '{propertySymbol.ContainingType.Name}'");
diff --git a/src/Tools/CodeGeneration/CSharp/SyntaxWalker/CSharpSyntaxWalkerGenerator.cs b/src/Tools/CodeGeneration/CSharp/SyntaxWalker/CSharpSyntaxWalkerGenerator.cs
index 8b9a6948ed..7490a79a65 100644
--- a/src/Tools/CodeGeneration/CSharp/SyntaxWalker/CSharpSyntaxWalkerGenerator.cs
+++ b/src/Tools/CodeGeneration/CSharp/SyntaxWalker/CSharpSyntaxWalkerGenerator.cs
@@ -90,6 +90,7 @@ public List<MemberDeclarationSyntax> CreateMemberDeclarations()
             AddIfNotNull(CreateVisitAbstractSyntaxMethodDeclaration(Microsoft_CodeAnalysis_CSharp_Syntax_VariableDesignationSyntax));
             AddIfNotNull(CreateVisitAbstractSyntaxMethodDeclaration(Microsoft_CodeAnalysis_CSharp_Syntax_XmlAttributeSyntax));
             AddIfNotNull(CreateVisitAbstractSyntaxMethodDeclaration(Microsoft_CodeAnalysis_CSharp_Syntax_XmlNodeSyntax));
+            AddIfNotNull(CreateVisitAbstractSyntaxMethodDeclaration(Microsoft_CodeAnalysis_CSharp_Syntax_CollectionElementSyntax));
         }
 
         return members;
@@ -410,6 +411,7 @@ private static string GetMethodName(ITypeSymbol typeSymbol)
                 case "XmlAttributeSyntax":
                 case "XmlNodeSyntax":
                 case "BaseExpressionColonSyntax":
+                case "CollectionElementSyntax":
                     {
                         if (typeSymbol
                             .ContainingNamespace
diff --git a/src/VisualStudioCode/package/src/configurationFiles.generated.ts b/src/VisualStudioCode/package/src/configurationFiles.generated.ts
index c410d94f27..5879b70c11 100644
--- a/src/VisualStudioCode/package/src/configurationFiles.generated.ts
+++ b/src/VisualStudioCode/package/src/configurationFiles.generated.ts
@@ -139,6 +139,9 @@ roslynator_analyzers.enabled_by_default = true|false
 #roslynator_use_block_body_when_expression_spans_over_multiple_lines = true|false
 # Applicable to: rcs1016
 
+#roslynator_use_collection_expression = true|false
+# Applicable to: rcs1014, rcs1250
+
 #roslynator_use_var_instead_of_implicit_object_creation = true|false
 # Applicable to: rcs1250
 
@@ -341,7 +344,7 @@ roslynator_analyzers.enabled_by_default = true|false
 
 # Use explicitly/implicitly typed array
 #dotnet_diagnostic.rcs1014.severity = none
-# Options: roslynator_array_creation_type_style
+# Options: roslynator_array_creation_type_style, roslynator_use_collection_expression
 
 # Use nameof operator
 #dotnet_diagnostic.rcs1015.severity = suggestion
@@ -870,7 +873,7 @@ roslynator_analyzers.enabled_by_default = true|false
 
 # Use implicit/explicit object creation
 #dotnet_diagnostic.rcs1250.severity = none
-# Options: roslynator_object_creation_type_style, roslynator_use_var_instead_of_implicit_object_creation
+# Options: roslynator_object_creation_type_style, roslynator_use_collection_expression, roslynator_use_var_instead_of_implicit_object_creation
 
 # Remove unnecessary braces from record declaration
 #dotnet_diagnostic.rcs1251.severity = suggestion