Merge pull request #4925 from mattwar/Issue3829

Add ArrayCreationExpression to SyntaxGenerator

src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs

@@ -3421,6 +3421,24 @@ private ExpressionSyntax ParenthesizeLeft(ExpressionSyntax expression)
             }
         }
 
+        private SeparatedSyntaxList<ExpressionSyntax> AsExpressionList(IEnumerable<SyntaxNode> expressions)
+        {
+            return SyntaxFactory.SeparatedList(expressions.OfType<ExpressionSyntax>());
+        }
+
+        public override SyntaxNode ArrayCreationExpression(SyntaxNode elementType, SyntaxNode size)
+        {
+            var arrayType = SyntaxFactory.ArrayType((TypeSyntax)elementType, SyntaxFactory.SingletonList(SyntaxFactory.ArrayRankSpecifier(SyntaxFactory.SingletonSeparatedList((ExpressionSyntax)size))));
+            return SyntaxFactory.ArrayCreationExpression(arrayType);
+        }
+
+        public override SyntaxNode ArrayCreationExpression(SyntaxNode elementType, IEnumerable<SyntaxNode> elements)
+        {
+            var arrayType = SyntaxFactory.ArrayType((TypeSyntax)elementType, SyntaxFactory.SingletonList(SyntaxFactory.ArrayRankSpecifier()));
+            var initializer = SyntaxFactory.InitializerExpression(SyntaxKind.ArrayInitializerExpression, AsExpressionList(elements));
+            return SyntaxFactory.ArrayCreationExpression(arrayType, initializer);
+        }
+
         public override SyntaxNode ObjectCreationExpression(SyntaxNode type, IEnumerable<SyntaxNode> arguments)
         {
             return SyntaxFactory.ObjectCreationExpression((TypeSyntax)type, CreateArgumentList(arguments), null);

src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs

@@ -313,6 +313,18 @@ public void TestMemberAccessExpressions()
             VerifySyntax<MemberAccessExpressionSyntax>(_g.MemberAccessExpression(_g.NegateExpression(_g.IdentifierName("x")), _g.IdentifierName("y")), "(-(x)).y");
         }
 
+        [Fact]
+        public void TestArrayCreationExpressions()
+        {
+            VerifySyntax<ArrayCreationExpressionSyntax>(
+                _g.ArrayCreationExpression(_g.IdentifierName("x"), _g.LiteralExpression(10)),
+                "new x[10]");
+
+            VerifySyntax<ArrayCreationExpressionSyntax>(
+                _g.ArrayCreationExpression(_g.IdentifierName("x"), new SyntaxNode[] { _g.IdentifierName("y"), _g.IdentifierName("z") }),
+                "new x[]{y, z}");
+        }
+
         [Fact]
         public void TestObjectCreationExpressions()
         {

src/Workspaces/Core/Portable/Editing/SyntaxGenerator.cs

@@ -1625,6 +1625,16 @@ public SyntaxNode MemberAccessExpression(SyntaxNode expression, string memberNam
             return MemberAccessExpression(expression, IdentifierName(memberName));
         }
 
+        /// <summary>
+        /// Creates an array creation expression for a single dimensional array of specified size.
+        /// </summary>
+        public abstract SyntaxNode ArrayCreationExpression(SyntaxNode elementType, SyntaxNode size);
+
+        /// <summary>
+        /// Creates an array creation expression for a single dimensional array with specified initial element values.
+        /// </summary>
+        public abstract SyntaxNode ArrayCreationExpression(SyntaxNode elementType, IEnumerable<SyntaxNode> elements);
+
         /// <summary>
         /// Creates an object creation expression.
         /// </summary>

src/Workspaces/Core/Portable/PublicAPI.Unshipped.txt

 Microsoft.CodeAnalysis.Editing.SyntaxEditor.RemoveNode(Microsoft.CodeAnalysis.SyntaxNode node, Microsoft.CodeAnalysis.SyntaxRemoveOptions options) -> void
 Microsoft.CodeAnalysis.Project.IsSubmission.get -> bool
 Microsoft.CodeAnalysis.Workspace.UpdateReferencesAfterAdd() -> void
+abstract Microsoft.CodeAnalysis.Editing.SyntaxGenerator.ArrayCreationExpression(Microsoft.CodeAnalysis.SyntaxNode elementType, Microsoft.CodeAnalysis.SyntaxNode size) -> Microsoft.CodeAnalysis.SyntaxNode
+abstract Microsoft.CodeAnalysis.Editing.SyntaxGenerator.ArrayCreationExpression(Microsoft.CodeAnalysis.SyntaxNode elementType, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxNode> elements) -> Microsoft.CodeAnalysis.SyntaxNode
 static Microsoft.CodeAnalysis.CodeActions.CodeAction.Create(string title, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.CodeActions.CodeAction> nestedActions, string equivalenceKey = null) -> Microsoft.CodeAnalysis.CodeActions.CodeAction
 static Microsoft.CodeAnalysis.Editing.SyntaxGenerator.GetGenerator(Microsoft.CodeAnalysis.Project project) -> Microsoft.CodeAnalysis.Editing.SyntaxGenerator
 virtual Microsoft.CodeAnalysis.Editing.SyntaxGenerator.RemoveNode(Microsoft.CodeAnalysis.SyntaxNode root, Microsoft.CodeAnalysis.SyntaxNode node, Microsoft.CodeAnalysis.SyntaxRemoveOptions options) -> Microsoft.CodeAnalysis.SyntaxNode
\ No newline at end of file

src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicSyntaxGenerator.vb

@@ -224,6 +224,22 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             Return SyntaxFactory.UnaryMinusExpression(Parenthesize(expression))
         End Function
 
+        Private Function AsExpressionList(expressions As IEnumerable(Of SyntaxNode)) As SeparatedSyntaxList(Of ExpressionSyntax)
+            Return SyntaxFactory.SeparatedList(Of ExpressionSyntax)(expressions.OfType(Of ExpressionSyntax)())
+        End Function
+
+        Public Overrides Function ArrayCreationExpression(elementType As SyntaxNode, size As SyntaxNode) As SyntaxNode
+            Dim sizes = SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(AsArgument(size)))
+            Dim initializer = SyntaxFactory.CollectionInitializer()
+            Return SyntaxFactory.ArrayCreationExpression(Nothing, DirectCast(elementType, TypeSyntax), sizes, initializer)
+        End Function
+
+        Public Overrides Function ArrayCreationExpression(elementType As SyntaxNode, elements As IEnumerable(Of SyntaxNode)) As SyntaxNode
+            Dim sizes = SyntaxFactory.ArgumentList()
+            Dim initializer = SyntaxFactory.CollectionInitializer(AsExpressionList(elements))
+            Return SyntaxFactory.ArrayCreationExpression(Nothing, DirectCast(elementType, TypeSyntax), sizes, initializer)
+        End Function
+
         Public Overloads Overrides Function ObjectCreationExpression(typeName As SyntaxNode, arguments As IEnumerable(Of SyntaxNode)) As SyntaxNode
             Return SyntaxFactory.ObjectCreationExpression(
                 Nothing,

src/Workspaces/VisualBasicTest/CodeGeneration/SyntaxGeneratorTests.vb

@@ -327,6 +327,17 @@ End Class
             VerifySyntax(Of MemberAccessExpressionSyntax)(_g.MemberAccessExpression(_g.NegateExpression(_g.IdentifierName("x")), _g.IdentifierName("y")), "(-(x)).y")
         End Sub
 
+        <Fact>
+        Public Sub TestArrayCreationExpressions()
+            VerifySyntax(Of ArrayCreationExpressionSyntax)(
+                _g.ArrayCreationExpression(_g.IdentifierName("x"), _g.LiteralExpression(10)),
+                "New x(10) {}")
+
+            VerifySyntax(Of ArrayCreationExpressionSyntax)(
+                _g.ArrayCreationExpression(_g.IdentifierName("x"), {_g.IdentifierName("y"), _g.IdentifierName("z")}),
+                "New x() {y, z}")
+        End Sub
+
         <Fact>
         Public Sub TestObjectCreationExpressions()
             VerifySyntax(Of ObjectCreationExpressionSyntax)(