public static void Go(OutputWriter writer, ImplicitArrayCreationExpressionSyntax array)
{
var ti = TypeProcessor.GetTypeInfo(array);
var t = ti.Type;
if (ti.ConvertedType != null && !(ti.ConvertedType == t)) // Alot of times we are using covariance here
{
t = ti.ConvertedType;
}
var ptr = !t.As <IArrayTypeSymbol>().ElementType.IsValueType; // ? "" : "";
var elementType = t.As <IArrayTypeSymbol>().ElementType;
var type = TypeProcessor.ConvertType(elementType);
var typeString = "Array_T!(" + type + ")";
var tempWriter = new TempWriter();
tempWriter.Indent = writer.Indent;
if (elementType.TypeKind == TypeKind.TypeParameter)
{
tempWriter.Write(" __TypeNew!(" + typeString + ")([");
}
else
{
tempWriter.Write("new " + typeString + "(");
}
//__ARRAY
var variableDeclarationSyntax = array.Parent.Parent.Parent as VariableDeclarationSyntax;
// var argumentSyntax = array.Parent as ArgumentSyntax;
if (variableDeclarationSyntax != null)
{
var atype = variableDeclarationSyntax.Type;
array.Initializer.WriteArrayInitializer(tempWriter, atype);
}
else
{
array.Initializer.WriteArrayInitializer(tempWriter, t);
}
tempWriter.Write(")");
var tempString = tempWriter.ToString();
var oldString = tempString;
tempString = tempString.Replace("new " + typeString + "(__CC!(" + type + "[])(", "__ARRAY!(" + type + ")(");
if (tempString != oldString)
{
tempString = tempString.RemoveFromEndOfString(")");
}
writer.Write(tempString);
}
public static async Task <Document> RefactorAsync(
Document document,
ImplicitArrayCreationExpressionSyntax implicitArrayCreation,
CancellationToken cancellationToken = default)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(implicitArrayCreation, cancellationToken);
var arrayType = (ArrayTypeSyntax)typeSymbol.ToTypeSyntax().WithSimplifierAnnotation();
SyntaxToken newKeyword = implicitArrayCreation.NewKeyword;
if (!newKeyword.HasTrailingTrivia)
{
newKeyword = newKeyword.WithTrailingTrivia(SyntaxFactory.Space);
}
ArrayCreationExpressionSyntax newNode = SyntaxFactory.ArrayCreationExpression(
newKeyword,
arrayType
.WithLeadingTrivia(implicitArrayCreation.OpenBracketToken.LeadingTrivia)
.WithTrailingTrivia(implicitArrayCreation.CloseBracketToken.TrailingTrivia),
implicitArrayCreation.Initializer);
return(await document.ReplaceNodeAsync(implicitArrayCreation, newNode, cancellationToken).ConfigureAwait(false));
}
public static void Go(ScalaWriter writer, ImplicitArrayCreationExpressionSyntax array)
{
writer.Write("Array");
//var t = Program.GetModel(array).GetTypeInfo(array).Type;
//if (t is IArrayTypeSymbol)
//{
// writer.Write("[");
// writer.Write(TypeProcessor.ConvertType(t.As<IArrayTypeSymbol>().ElementType));
// writer.Write("]");
//}
writer.Write("(");
bool first = true;
foreach (var expression in array.Initializer.Expressions)
{
if (first)
{
first = false;
}
else
{
writer.Write(", ");
}
Core.Write(writer, expression);
}
writer.Write(")");
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
SyntaxNode root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
ImplicitArrayCreationExpressionSyntax expression = root
.FindNode(context.Span, getInnermostNodeForTie: true)?
.FirstAncestorOrSelf <ImplicitArrayCreationExpressionSyntax>();
if (expression != null &&
context.Document.SupportsSemanticModel)
{
SemanticModel semanticModel = await context.Document.GetSemanticModelAsync(context.CancellationToken).ConfigureAwait(false);
var typeSymbol = semanticModel
.GetTypeInfo(expression, context.CancellationToken)
.Type as IArrayTypeSymbol;
if (typeSymbol?.ElementType?.IsErrorType() == false)
{
var arrayType = CSharpFactory.Type(typeSymbol) as ArrayTypeSyntax;
if (arrayType != null)
{
CodeAction codeAction = CodeAction.Create(
$"Declare explicit type '{typeSymbol.ToMinimalDisplayString(semanticModel, expression.Span.Start, SyntaxUtility.DefaultSymbolDisplayFormat)}'",
cancellationToken => RefactorAsync(context.Document, expression, arrayType, cancellationToken),
DiagnosticIdentifiers.AvoidImplicitlyTypedArray + EquivalenceKeySuffix);
context.RegisterCodeFix(codeAction, context.Diagnostics);
}
}
}
}
public static string ImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax array)
{
var output = "[ ";
output += array.Initializer.Expressions.ConvertSeparatedSyntaxList();
return(output + " ]");
}
public static string ImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax node)
{
var output = "[ ";
output += string.Join(", ", node.Initializer.Expressions.Select(SyntaxNode));
return(output + " ]");
}
public override IStmt VisitImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax node)
{
return(new IndexExpr
{
Elements = node.Initializer.Expressions.Select(Visit).ToArray()
});
}
private static async Task <Document> ChangeArrayTypeToExplicitAsync(
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;
if (!newKeyword.HasTrailingTrivia)
{
newKeyword = newKeyword.WithTrailingTrivia(Space);
}
InitializerExpressionSyntax initializer = implicitArrayCreation.Initializer;
InitializerExpressionSyntax newInitializer = initializer.ReplaceNodes(
initializer.Expressions,
(node, _) => (node.IsKind(SyntaxKind.CastExpression)) ? node.WithSimplifierAnnotation() : node);
ArrayCreationExpressionSyntax newNode = ArrayCreationExpression(
newKeyword,
arrayType
.WithLeadingTrivia(implicitArrayCreation.OpenBracketToken.LeadingTrivia)
.WithTrailingTrivia(implicitArrayCreation.CloseBracketToken.TrailingTrivia),
newInitializer);
return(await document.ReplaceNodeAsync(implicitArrayCreation, newNode, cancellationToken).ConfigureAwait(false));
}
public override BoundNode VisitImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax node)
{
if (node.Commas.Count != 0)
{
throw new NotSupportedException(
"Multidimensional arrays are not yet supported by UdonSharp, consider using jagged arrays instead.",
node.GetLocation());
}
// Almost certainly needs to be revisited for jagged arrays
TypeSymbol arrayType = GetTypeSymbol(node);
var initializerExpressions = node.Initializer.Expressions;
BoundExpression[] elementCounts = { new BoundConstantExpression(new ConstantValue <int>(initializerExpressions.Count), Context.GetTypeSymbol(SpecialType.System_Int32), node) };
BoundExpression[] initializers = new BoundExpression[initializerExpressions.Count];
TypeSymbol elementType = arrayType.ElementType;
for (int i = 0; i < initializers.Length; ++i)
{
initializers[i] = VisitExpression(initializerExpressions[i], elementType);
}
return(new BoundArrayCreationExpression(node, Context, arrayType, elementCounts, initializers));
}
public override IEnumerable <IModel> VisitImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax node)
{
var model = Create <ImplicitArrayCreationExpression>(node);
model.Initializer = TransformToSingle <InitializerExpression>(node.Initializer);
yield return(model);
}
public static void Write(this ImplicitArrayCreationExpressionSyntax syntax, IIndentedTextWriterWrapper textWriter, IContext context)
{
var typeInfo = context.SemanticModel.GetTypeInfo(syntax);
textWriter.Write("(");
context.TypeReferenceWriter.WriteInteractionElementReference(typeInfo.Type, textWriter);
textWriter.Write("._C_0_0() % _M.DOT)");
syntax.Initializer.Write(textWriter, context);
}
private IEnumerable <Instruction> ProcessImplicitArrayCreation(ImplicitArrayCreationExpressionSyntax implicitArrayExpression)
{
// e.g. string[] a2 = new[] { data, data }
// Need to look at the ConvertedType in this case since the implicit array creation type is null
if (!(this.semanticModel.GetTypeInfo(implicitArrayExpression).ConvertedType is IArrayTypeSymbol arrayType))
{
return(NoInstructions);
}
return(BuildNewArrayInstance(implicitArrayExpression, arrayType));
}
public override SyntaxNode VisitImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax node)
{
if (NormalizeWhitespaceOnly && _checkingMethod != RegisterInstanceName)
{
var closeBracket = node.CloseBracketToken.WithTrailingTrivia(SyntaxHelper.EndOfLineTrivia);
node = node.WithCloseBracketToken(closeBracket);
node = node.WithInitializer(RewriteInitializer(node.Initializer));
}
return(base.VisitImplicitArrayCreationExpression(node));
}
private static ArrayCreationExpressionSyntax CreateArrayCreationExpression(
ImplicitArrayCreationExpressionSyntax node,
ArrayTypeSyntax arrayType)
{
return(SyntaxFactory.ArrayCreationExpression(
node.NewKeyword,
arrayType
.WithSimplifierAnnotation()
.WithTrailingTrivia(node.CloseBracketToken.TrailingTrivia),
node.Initializer));
}
public override Ust VisitImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax node)
{
var type = new TypeToken(CommonUtils.Prefix + "object", node.NewKeyword.GetTextSpan());
var sizes = node.Commas.Select(c => new IntLiteral(0, c.GetTextSpan())).ToList();
sizes.Add(new IntLiteral(0, node.CloseBracketToken.GetTextSpan()));
var result = new ArrayCreationExpression(type, sizes, new Expression[0], node.GetTextSpan());
return(result);
}
public override SyntaxNode VisitImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax node)
{
var type = sem.GetTypeInfo(node).Type;
var newNode = (ImplicitArrayCreationExpressionSyntax)base.VisitImplicitArrayCreationExpression(node);
var arrayType = ArrayType(ParseTypeName(type.ToDisplayString(displayFormat)).WithLeadingTrivia(Space));
return(ArrayCreationExpression(arrayType)
.WithInitializer(newNode.Initializer)
.WithTriviaFrom(newNode));
}
public static void Go(OutputWriter writer, ImplicitArrayCreationExpressionSyntax array)
{
var ti = TypeProcessor.GetTypeInfo(array);
var t = ti.Type;
if (ti.ConvertedType!=null && !(ti.ConvertedType == t)) // Alot of times we are using covariance here
{
t = ti.ConvertedType;
}
var ptr = !t.As<IArrayTypeSymbol>().ElementType.IsValueType; // ? "" : "";
var elementType = t.As<IArrayTypeSymbol>().ElementType;
var type = TypeProcessor.ConvertType(elementType);
var typeString = "Array_T!(" + type + ")";
var tempWriter = new TempWriter();
tempWriter.Indent = writer.Indent;
if (elementType.TypeKind == TypeKind.TypeParameter)
tempWriter.Write(" __TypeNew!(" + typeString + ")([");
else
{
tempWriter.Write("new " + typeString + "(");
}
//__ARRAY
var variableDeclarationSyntax = array.Parent.Parent.Parent as VariableDeclarationSyntax;
// var argumentSyntax = array.Parent as ArgumentSyntax;
if (variableDeclarationSyntax != null)
{
var atype = variableDeclarationSyntax.Type;
array.Initializer.WriteArrayInitializer(tempWriter, atype);
}
else
array.Initializer.WriteArrayInitializer(tempWriter,t);
tempWriter.Write(")");
var tempString = tempWriter.ToString();
var oldString = tempString;
tempString = tempString.Replace("new " + typeString + "(__CC!(" + type + "[])(", "__ARRAY!(" + type + ")(");
if (tempString != oldString)
tempString = tempString.RemoveFromEndOfString(")");
writer.Write(tempString);
}
public static Doc Print(ImplicitArrayCreationExpressionSyntax node)
{
var commas = node.Commas.Select(Token.Print).ToArray();
return(Doc.Concat(
Token.Print(node.NewKeyword),
Token.Print(node.OpenBracketToken),
Doc.Concat(commas),
Token.Print(node.CloseBracketToken, " "),
Node.Print(node.Initializer)
));
}
public override JsExpression VisitImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax node)
{
var type = (IArrayTypeSymbol)model.GetTypeInfo(node).ConvertedType;
var elementType = type.ElementType;
var newArrayInit = GetExpressionMethod("NewArrayInit", Context.Instance.TypeType, Context.Instance.ExpressionArray);
var jsMethod = idioms.InvokeStatic(
newArrayInit,
idioms.TypeOf(elementType),
idioms.Array(Context.Instance.ExpressionArray, node.Initializer.Expressions.Select(x => x.Accept(this)).ToArray()));
return(jsMethod);
}
public override void VisitImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax node)
{
if (!PreVisit(node))
{
return;
}
node.Initializer?.Accept(this);
base.VisitImplicitArrayCreationExpression(node);
PostVisit(node);
}
private Doc PrintImplicitArrayCreationExpressionSyntax(
ImplicitArrayCreationExpressionSyntax node)
{
var commas = node.Commas.Select(o => this.PrintSyntaxToken(o))
.ToArray();
return(Concat(
this.PrintSyntaxToken(node.NewKeyword),
this.PrintSyntaxToken(node.OpenBracketToken),
Concat(commas),
this.PrintSyntaxToken(node.CloseBracketToken, " "),
this.Print(node.Initializer)
));
}
private static async Task FindAnonymousTypesWithMessageContractsInTree(IDictionary <AnonymousObjectCreationExpressionSyntax, ITypeSymbol> dictionary,
ImplicitArrayCreationExpressionSyntax implicitArrayCreationExpressionSyntax, ITypeSymbol contractElementType, SemanticModel semanticModel)
{
SeparatedSyntaxList <ExpressionSyntax> expressions = implicitArrayCreationExpressionSyntax.Initializer.Expressions;
foreach (var expression in expressions)
{
if (expression is AnonymousObjectCreationExpressionSyntax anonymousObjectArrayInitializer)
{
await FindAnonymousTypesWithMessageContractsInTree(dictionary, anonymousObjectArrayInitializer,
contractElementType, semanticModel).ConfigureAwait(false);
}
}
}
public override LuaSyntaxNode VisitImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax node)
{
var symbol = semanticModel_.GetTypeInfo(node.Initializer.Expressions.First()).Type;
LuaExpressionSyntax elementTypeExpression = GetTypeName(symbol);
LuaInvocationExpressionSyntax arrayTypeExpression = new LuaInvocationExpressionSyntax(LuaIdentifierNameSyntax.Array, elementTypeExpression);
LuaInvocationExpressionSyntax invocation = new LuaInvocationExpressionSyntax(arrayTypeExpression);
foreach (var expression in node.Initializer.Expressions)
{
var element = (LuaExpressionSyntax)expression.Accept(this);
invocation.AddArgument(element);
}
return(invocation);
}
private static async Task <Document> SpecifyExplicitTypeAsync(
Document document,
ImplicitArrayCreationExpressionSyntax node,
ArrayTypeSyntax arrayType,
CancellationToken cancellationToken)
{
SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken);
ArrayCreationExpressionSyntax newNode = CreateArrayCreationExpression(node, arrayType)
.WithAdditionalAnnotations(Formatter.Annotation);
SyntaxNode newRoot = oldRoot.ReplaceNode(node, newNode);
return(document.WithSyntaxRoot(newRoot));
}
public override void VisitImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax node)
{
var arrayType = Context.GetTypeInfo(node);
if (arrayType.Type == null)
{
throw new Exception($"Unable to infer array type: {node}");
}
AddCilInstruction(ilVar, OpCodes.Ldc_I4, node.Initializer.Expressions.Count);
var arrayTypeSymbol = (IArrayTypeSymbol)arrayType.Type;
ProcessArrayCreation(arrayTypeSymbol.ElementType, node.Initializer);
}
private static async Task <Document> RefactorAsync(
Document document,
ImplicitArrayCreationExpressionSyntax node,
ArrayTypeSyntax arrayType,
CancellationToken cancellationToken = default(CancellationToken))
{
SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
ArrayCreationExpressionSyntax newNode = CreateArrayCreationExpression(node, arrayType)
.WithFormatterAnnotation();
SyntaxNode newRoot = root.ReplaceNode(node, newNode);
return(document.WithSyntaxRoot(newRoot));
}
public static void Go(OutputWriter writer, ImplicitArrayCreationExpressionSyntax array)
{
var t = TypeProcessor.GetTypeInfo(array).Type;
var ptr = !t.As <IArrayTypeSymbol>().ElementType.IsValueType; // ? "" : "";
var elementType = t.As <IArrayTypeSymbol>().ElementType;
var type = TypeProcessor.ConvertType(elementType);
var typeString = "Array_T!(" + type + ")";
if (elementType.TypeKind == TypeKind.TypeParameter)
{
writer.Write(" __TypeNew!(" + typeString + ")([");
}
else
{
writer.Write("new " + typeString + "(");
}
var variableDeclarationSyntax = array.Parent.Parent.Parent as VariableDeclarationSyntax;
if (variableDeclarationSyntax != null)
{
var atype = variableDeclarationSyntax.Type;
array.Initializer.WriteArrayInitializer(writer, atype);
}
else
{
array.Initializer.WriteArrayInitializer(writer);
}
// array.Initializer.WriteArrayInitializer(writer,);
// bool first = true;
// foreach (var expression in array.Initializer.Expressions)
// {
// if (first)
// first = false;
// else
// writer.Write(",");
//
// Core.Write(writer, expression);
// }
writer.Write(")");
}
public static int?TryGetSizeOfSingleDimensionalNonJaggedArray(ExpressionSyntax?arrayCreationExpression, SemanticModel?semanticModel = null,
CancellationToken cancellationToken = default)
{
return(arrayCreationExpression switch
{
ArrayCreationExpressionSyntax arrayCreation
when arrayCreation.Initializer != null => arrayCreation.Initializer.Expressions.Count,
ArrayCreationExpressionSyntax arrayCreationWithouInitializer => TryGetSizeOfSingleDimensionalNonJaggedArray(arrayCreationWithouInitializer.Type,
semanticModel, cancellationToken),
ImplicitArrayCreationExpressionSyntax implicitArrayCreation => implicitArrayCreation.Initializer?.Expressions.Count,
InitializerExpressionSyntax initializerExpression
when initializerExpression.IsKind(SyntaxKind.ArrayInitializerExpression) => initializerExpression.Expressions.Count,
StackAllocArrayCreationExpressionSyntax stackAllocArrayCreation
when stackAllocArrayCreation.Type is ArrayTypeSyntax arrayType => TryGetSizeOfSingleDimensionalNonJaggedArray(arrayType, semanticModel,
cancellationToken),
_ => null
});
public static async Task <Document> RefactorAsync(
Document document,
ImplicitArrayCreationExpressionSyntax expression,
CancellationToken cancellationToken = default(CancellationToken))
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(expression, cancellationToken);
var arrayType = CSharpFactory.Type(typeSymbol, semanticModel, expression.SpanStart) as ArrayTypeSyntax;
ArrayCreationExpressionSyntax newNode = SyntaxFactory.ArrayCreationExpression(
expression.NewKeyword,
arrayType.WithTrailingTrivia(expression.CloseBracketToken.TrailingTrivia),
expression.Initializer);
newNode = newNode.WithFormatterAnnotation();
return(await document.ReplaceNodeAsync(expression, newNode, cancellationToken).ConfigureAwait(false));
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
SyntaxNode root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
ImplicitArrayCreationExpressionSyntax node = root
.FindNode(context.Span, getInnermostNodeForTie: true)?
.FirstAncestorOrSelf <ImplicitArrayCreationExpressionSyntax>();
if (node == null)
{
return;
}
SemanticModel semanticModel = await context.Document.GetSemanticModelAsync(context.CancellationToken);
if (semanticModel == null)
{
return;
}
ITypeSymbol typeSymbol = semanticModel.GetTypeInfo(node, context.CancellationToken).Type;
if (typeSymbol == null)
{
return;
}
var arrayType = TypeSyntaxRefactoring.CreateTypeSyntax(typeSymbol) as ArrayTypeSyntax;
if (arrayType == null)
{
return;
}
CodeAction codeAction = CodeAction.Create(
$"Declare explicit type '{typeSymbol.ToDisplayString(TypeSyntaxRefactoring.SymbolDisplayFormat)}'",
cancellationToken => SpecifyExplicitTypeAsync(context.Document, node, arrayType, cancellationToken),
DiagnosticIdentifiers.AvoidImplicitArrayCreation + EquivalenceKeySuffix);
context.RegisterCodeFix(codeAction, context.Diagnostics);
}
private async Task <Document> SimplifyParamsParametersAsync(
Document document,
ImplicitArrayCreationExpressionSyntax newArray,
CancellationToken cancellationToken)
{
var arg = (ArgumentSyntax)newArray.Parent;
var argList = (ArgumentListSyntax)arg.Parent;
var argListWithoutParamsArray = argList.Arguments.Remove(arg);
ArgumentListSyntax resultingArgs = SyntaxFactory.ArgumentList(
argListWithoutParamsArray
.AddRange(newArray.Initializer.Expressions.Select(SyntaxFactory.Argument)));
// Replace the old local declaration with the new local declaration.
var oldRoot = await document.GetSyntaxRootAsync(cancellationToken);
var newRoot = oldRoot.ReplaceNode(argList, resultingArgs);
// Return document with transformed tree.
return(document.WithSyntaxRoot(newRoot));
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax node)
{
this.OnNodeVisited(node, this.type.IsInstanceOfType(node));
base.VisitImplicitArrayCreationExpression(node);
}
public override void VisitImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax node)
{
base.VisitImplicitArrayCreationExpression(node);
}
public ImplicitArrayCreationExpressionTranslation(ImplicitArrayCreationExpressionSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
Initializer = syntax.Initializer.Get<InitializerExpressionTranslation>(this);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax node)
{
this.OnNodeVisited(node);
if (!this.traverseRootOnly) base.VisitImplicitArrayCreationExpression(node);
}
public static string ImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax array)
{
var output = "[ ";
output += string.Join(", ", array.Initializer.Expressions.Select(SyntaxNode));
return output + " ]";
}
public void VisitImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax node)
{
if (node == null)
throw new ArgumentNullException("node");
node.Validate();
ExpressionStart(node);
if (_writer.Configuration.Other.AlignMultiLineConstructs.ArrayObjectCollectionInitializer)
_writer.SetAlignmentBreak(true);
_writer.WriteKeyword(PrinterKeyword.New);
_writer.WriteSyntax(Syntax.OpenBracket);
for (int i = 0; i < node.Commas.GetValueOrDefault(0); i++)
{
_writer.WriteListSeparator();
}
_writer.WriteSyntax(Syntax.CloseBracket);
_writer.PushBraceFormatting(_writer.Configuration.BracesLayout.ArrayAndObjectInitializer, false);
node.Initializer.Accept(this);
_writer.PopBraceFormatting();
if (_writer.Configuration.Other.AlignMultiLineConstructs.ArrayObjectCollectionInitializer)
_writer.SetAlignmentBreak(false);
ExpressionEnd(node);
}