private CodeExpression ParseConstructorArguments(ParserContext parserContext, Type type, bool assignIsEquality)
{
System.Diagnostics.Debug.Assert(parserContext.CurrentToken.TokenID == TokenID.LParen);
// Start of a constructor parameter list.
int lparenPosition = parserContext.CurrentToken.StartPosition;
parserContext.NextToken();
if (parserContext.CurrentToken.TokenID == TokenID.EndOfInput && parserContext.provideIntellisense)
{
parserContext.SetConstructorCompletions(type, Validator.ThisType);
return null;
}
List<CodeExpression> arguments = ParseArgumentList(parserContext);
if ((type.IsValueType) && (arguments.Count == 0))
{
// this is always allowed
}
else if (type.IsAbstract)
{
// this is not allowed
string message = string.Format(CultureInfo.CurrentCulture,
Messages.UnknownConstructor,
RuleDecompiler.DecompileType(type));
throw new RuleSyntaxException(ErrorNumbers.Error_MethodNotExists, message, lparenPosition);
}
else
{
// Binding flags include all public & non-public, all instance, and all static.
// All are possible candidates for unadorned method references.
BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.FlattenHierarchy | BindingFlags.Instance;
if (type.Assembly == validation.ThisType.Assembly)
bindingFlags |= BindingFlags.NonPublic;
ValidationError error = null;
RuleConstructorExpressionInfo constructorInvokeInfo = validation.ResolveConstructor(type, bindingFlags, arguments, out error);
if (constructorInvokeInfo == null)
throw new RuleSyntaxException(error.ErrorNumber, error.ErrorText, lparenPosition);
}
CodeExpression postfixExpr = new CodeObjectCreateExpression(type, arguments.ToArray());
parserContext.exprPositions[postfixExpr] = lparenPosition;
ValidateExpression(parserContext, postfixExpr, assignIsEquality, ValueCheck.Read);
return postfixExpr;
}
private CodeExpression ParseConstructorArguments(ParserContext parserContext, Type type, bool assignIsEquality)
{
int startPosition = parserContext.CurrentToken.StartPosition;
parserContext.NextToken();
if ((parserContext.CurrentToken.TokenID == TokenID.EndOfInput) && parserContext.provideIntellisense)
{
parserContext.SetConstructorCompletions(type, this.Validator.ThisType);
return null;
}
List<CodeExpression> argumentExprs = this.ParseArgumentList(parserContext);
if (!type.IsValueType || (argumentExprs.Count != 0))
{
if (type.IsAbstract)
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.UnknownConstructor, new object[] { RuleDecompiler.DecompileType(type) });
throw new RuleSyntaxException(0x137, message, startPosition);
}
BindingFlags constructorBindingFlags = BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Instance;
if (type.Assembly == this.validation.ThisType.Assembly)
{
constructorBindingFlags |= BindingFlags.NonPublic;
}
ValidationError error = null;
if (this.validation.ResolveConstructor(type, constructorBindingFlags, argumentExprs, out error) == null)
{
throw new RuleSyntaxException(error.ErrorNumber, error.ErrorText, startPosition);
}
}
CodeExpression expression = new CodeObjectCreateExpression(type, argumentExprs.ToArray());
parserContext.exprPositions[expression] = startPosition;
this.ValidateExpression(parserContext, expression, assignIsEquality, ValueCheck.Read);
return expression;
}