// Parse:
// object-creation-expression --> NEW type-name method-call-arguments
// array-creation-expression --> NEW array-spec
// --> NEW array-spec array-initializer
private CodeExpression ParseObjectCreation(ParserContext parserContext, bool assignIsEquality)
{
CodeExpression primaryExpr = null;
Token token = parserContext.CurrentToken;
CodeExpression size;
Type type = TryParseTypeSpecifierWithOptionalSize(parserContext, assignIsEquality, out size);
// handle intellisense, regardless of whether we get a type back or not
if (parserContext.provideIntellisense && parserContext.CurrentToken.TokenID == TokenID.EndOfInput)
{
// if we have a type, get only nested classes for it
// if we don't have a type, then take whatever is already set for completions
if (type != null)
parserContext.SetNestedClassCompletions(type, validation.ThisType);
return null;
}
if (type == null)
throw new RuleSyntaxException(ErrorNumbers.Error_InvalidTypeArgument, Messages.Parser_InvalidTypeArgument, token.StartPosition);
if (size == null)
{
// must be an object-creation-expression
if (parserContext.CurrentToken.TokenID != TokenID.LParen)
{
// [] are already handled by TryParseTypeSpecifierWithOptionalSize
throw new RuleSyntaxException(ErrorNumbers.Error_InvalidTypeArgument, Messages.Parser_InvalidNew, token.StartPosition);
}
primaryExpr = ParseConstructorArguments(parserContext, type, assignIsEquality);
}
else
{
// it's an array
List<CodeExpression> initializers = ParseArrayCreationArguments(parserContext);
if (initializers != null)
{
if (size == defaultSize)
primaryExpr = new CodeArrayCreateExpression(type, initializers.ToArray());
else
{
// both specified
primaryExpr = new CodeArrayCreateExpression(type, size);
((CodeArrayCreateExpression)primaryExpr).Initializers.AddRange(initializers.ToArray());
}
}
else
{
// no initializers, so size matters
if (size != defaultSize)
primaryExpr = new CodeArrayCreateExpression(type, size);
else
{
// neither specified, so error
throw new RuleSyntaxException(ErrorNumbers.Error_NoArrayCreationSize,
Messages.Parser_NoArrayCreationSize,
parserContext.CurrentToken.StartPosition);
}
}
ValidateExpression(parserContext, primaryExpr, assignIsEquality, ValueCheck.Read);
}
return primaryExpr;
}
private CodeExpression ParseObjectCreation(ParserContext parserContext, bool assignIsEquality)
{
CodeExpression expression = null;
CodeExpression expression2;
Token currentToken = parserContext.CurrentToken;
Type computedType = this.TryParseTypeSpecifierWithOptionalSize(parserContext, assignIsEquality, out expression2);
if (parserContext.provideIntellisense && (parserContext.CurrentToken.TokenID == TokenID.EndOfInput))
{
if (computedType != null)
{
parserContext.SetNestedClassCompletions(computedType, this.validation.ThisType);
}
return null;
}
if (computedType == null)
{
throw new RuleSyntaxException(0x18e, Messages.Parser_InvalidTypeArgument, currentToken.StartPosition);
}
if (expression2 == null)
{
if (parserContext.CurrentToken.TokenID != TokenID.LParen)
{
throw new RuleSyntaxException(0x18e, Messages.Parser_InvalidNew, currentToken.StartPosition);
}
return this.ParseConstructorArguments(parserContext, computedType, assignIsEquality);
}
List<CodeExpression> list = this.ParseArrayCreationArguments(parserContext);
if (list != null)
{
if (expression2 == defaultSize)
{
expression = new CodeArrayCreateExpression(computedType, list.ToArray());
}
else
{
expression = new CodeArrayCreateExpression(computedType, expression2);
((CodeArrayCreateExpression) expression).Initializers.AddRange(list.ToArray());
}
}
else
{
if (expression2 == defaultSize)
{
throw new RuleSyntaxException(0x1aa, Messages.Parser_NoArrayCreationSize, parserContext.CurrentToken.StartPosition);
}
expression = new CodeArrayCreateExpression(computedType, expression2);
}
this.ValidateExpression(parserContext, expression, assignIsEquality, ValueCheck.Read);
return expression;
}