/// <summary>
/// Reads an anonymous method from the code.
/// </summary>
/// <param name="parentReference">The parent code unit.</param>
/// <param name="unsafeCode">Indicates whether the code being parsed resides in an unsafe code block.</param>
/// <returns>Returns the expression.</returns>
private AnonymousMethodExpression GetAnonymousMethodExpression(Reference<ICodePart> parentReference, bool unsafeCode)
{
Param.AssertNotNull(parentReference, "parentReference");
Param.Ignore(unsafeCode);
var expressionReference = new Reference<ICodePart>();
// Get the delegate keyword.
Node<CsToken> firstTokenNode = this.tokens.InsertLast(
this.GetToken(CsTokenType.Delegate, SymbolType.Delegate, parentReference, expressionReference));
// Check whether the next symbol is an opening parenthesis.
Symbol symbol = this.GetNextSymbol(expressionReference);
ICollection<Parameter> parameters = null;
if (symbol.SymbolType == SymbolType.OpenParenthesis)
{
parameters = this.ParseAnonymousMethodParameterList(expressionReference, unsafeCode);
}
// Create the anonymous method object now.
AnonymousMethodExpression anonymousMethod = new AnonymousMethodExpression();
// The next symbol must be an opening curly bracket.
Bracket openingBracket = this.GetBracketToken(CsTokenType.OpenCurlyBracket, SymbolType.OpenCurlyBracket, expressionReference);
Node<CsToken> openingBracketNode = this.tokens.InsertLast(openingBracket);
// Read the child statements.
Node<CsToken> closingBracketNode = this.ParseStatementScope(anonymousMethod, expressionReference, unsafeCode);
if (closingBracketNode == null)
{
// If we failed to get a closing bracket back, then there is a syntax
// error in the document since there is an opening bracket with no matching
// closing bracket.
throw this.CreateSyntaxException();
}
openingBracket.MatchingBracketNode = closingBracketNode;
((Bracket)closingBracketNode.Value).MatchingBracketNode = openingBracketNode;
// Create the token list for the anonymous method expression.
anonymousMethod.Tokens = new CsTokenList(this.tokens, firstTokenNode, this.tokens.Last);
// Get the item's argument list if necessary.
if (parameters != null && parameters.Count > 0)
{
anonymousMethod.AddParameters(parameters);
}
// Add a variable for each of the parameters.
if (anonymousMethod.Parameters != null && anonymousMethod.Parameters.Count > 0)
{
// Add a variable for each of the parameters.
foreach (Parameter parameter in anonymousMethod.Parameters)
{
anonymousMethod.Variables.Add(new Variable(
parameter.Type, parameter.Name, VariableModifiers.None, parameter.Location, expressionReference, parameter.Generated));
}
}
// Return the expression.
expressionReference.Target = anonymousMethod;
return anonymousMethod;
}
private void CheckAnonymousMethodParenthesis(CsElement element, AnonymousMethodExpression expression)
{
if ((expression.Parameters == null) || (expression.Parameters.Count == 0))
{
for (Microsoft.StyleCop.Node<CsToken> node = expression.Tokens.First; node != expression.Tokens.Last; node = node.Next)
{
if (node.Value.CsTokenType == CsTokenType.OpenCurlyBracket)
{
return;
}
if (node.Value.CsTokenType == CsTokenType.OpenParenthesis)
{
base.AddViolation(element, node.Value.LineNumber, Microsoft.StyleCop.CSharp.Rules.RemoveDelegateParenthesisWhenPossible, new object[0]);
return;
}
}
}
}
private AnonymousMethodExpression GetAnonymousMethodExpression(bool unsafeCode)
{
Microsoft.StyleCop.Node<CsToken> firstItemNode = this.tokens.InsertLast(this.GetToken(CsTokenType.Delegate, SymbolType.Delegate));
Symbol nextSymbol = this.GetNextSymbol();
ICollection<Parameter> items = null;
if (nextSymbol.SymbolType == SymbolType.OpenParenthesis)
{
items = this.ParseAnonymousMethodParameterList(unsafeCode);
}
AnonymousMethodExpression parent = new AnonymousMethodExpression();
Bracket bracketToken = this.GetBracketToken(CsTokenType.OpenCurlyBracket, SymbolType.OpenCurlyBracket);
Microsoft.StyleCop.Node<CsToken> node2 = this.tokens.InsertLast(bracketToken);
Microsoft.StyleCop.Node<CsToken> node3 = this.ParseStatementScope(parent, unsafeCode);
if (node3 == null)
{
throw this.CreateSyntaxException();
}
bracketToken.MatchingBracketNode = node3;
((Bracket) node3.Value).MatchingBracketNode = node2;
parent.Tokens = new CsTokenList(this.tokens, firstItemNode, this.tokens.Last);
if ((items != null) && (items.Count > 0))
{
parent.AddParameters(items);
}
if ((parent.Parameters != null) && (parent.Parameters.Count > 0))
{
foreach (Parameter parameter in parent.Parameters)
{
parent.Variables.Add(new Variable(parameter.Type, parameter.Name, VariableModifiers.None, parameter.Location.StartPoint, parameter.Generated));
}
}
return parent;
}
/// <summary>
/// Checks that parenthesis are used correctly within an anonymous method.
/// </summary>
/// <param name="element">The parent element.</param>
/// <param name="expression">The expression to check.</param>
private void CheckAnonymousMethodParenthesis(CsElement element, AnonymousMethodExpression expression)
{
Param.AssertNotNull(element, "element");
Param.AssertNotNull(expression, "expression");
if (expression.Parameters == null || expression.Parameters.Count == 0)
{
// Check for parenthesis.
for (Node<CsToken> tokenNode = expression.Tokens.First; tokenNode != expression.Tokens.Last; tokenNode = tokenNode.Next)
{
if (tokenNode.Value.CsTokenType == CsTokenType.OpenCurlyBracket)
{
break;
}
else if (tokenNode.Value.CsTokenType == CsTokenType.OpenParenthesis)
{
this.AddViolation(element, tokenNode.Value.LineNumber, Rules.RemoveDelegateParenthesisWhenPossible);
break;
}
}
}
}
