// 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; }