internal static bool IsInAnonymousFunctionOrQuery(
int position,
SyntaxNode lambdaExpressionOrQueryNode
)
{
Debug.Assert(
lambdaExpressionOrQueryNode.IsAnonymousFunction() ||
lambdaExpressionOrQueryNode.IsQuery()
);
SyntaxToken firstIncluded;
CSharpSyntaxNode body;
switch (lambdaExpressionOrQueryNode.Kind())
{
case SyntaxKind.SimpleLambdaExpression:
SimpleLambdaExpressionSyntax simple =
(SimpleLambdaExpressionSyntax)lambdaExpressionOrQueryNode;
firstIncluded = simple.ArrowToken;
body = simple.Body;
break;
case SyntaxKind.ParenthesizedLambdaExpression:
ParenthesizedLambdaExpressionSyntax parenthesized =
(ParenthesizedLambdaExpressionSyntax)lambdaExpressionOrQueryNode;
firstIncluded = parenthesized.ArrowToken;
body = parenthesized.Body;
break;
case SyntaxKind.AnonymousMethodExpression:
AnonymousMethodExpressionSyntax anon =
(AnonymousMethodExpressionSyntax)lambdaExpressionOrQueryNode;
body = anon.Block;
firstIncluded = body.GetFirstToken(includeZeroWidth: true);
break;
default:
// OK, so we have some kind of query clause. They all start with a keyword token, so we'll skip that.
firstIncluded = lambdaExpressionOrQueryNode.GetFirstToken().GetNextToken();
return(IsBetweenTokens(
position,
firstIncluded,
lambdaExpressionOrQueryNode.GetLastToken().GetNextToken()
));
}
var bodyStatement = body as StatementSyntax;
var firstExcluded =
bodyStatement != null
? GetFirstExcludedToken(bodyStatement)
: (SyntaxToken)SyntaxNavigator.Instance.GetNextToken(
body,
predicate: null,
stepInto: null
);
return(IsBetweenTokens(position, firstIncluded, firstExcluded));
}
// We have a lambda; we want to find a syntax node or statement which can be bound such that
// we can get the type of the lambda, if there is one. For example if given
//
// A().B(x=>M(x)).C(); then we want to find A().B(x=>M())
// object d = (D)(x=>M(x)); then we want to find (D)(x=>M(x))
// D d = x=>M(x); then we want to find the whole thing.
//
protected virtual SyntaxNode GetBindableSyntaxNodeOfLambdaOrQuery(SyntaxNode node)
{
Debug.Assert(node != null);
Debug.Assert(node != this.Root);
Debug.Assert(node.IsAnonymousFunction() || node.IsQuery());
SyntaxNode current = node.Parent;
for (; current != this.Root; current = current.Parent)
{
Debug.Assert(current != null, "How did we get outside the root?");
if (current is StatementSyntax)
{
return current;
}
if (current.Kind == SyntaxKind.ParenthesizedExpression)
{
continue;
}
if (current is ExpressionSyntax)
{
return GetBindableSyntaxNode(current);
}
}
// We made it up to the root without finding a viable expression or statement. Just bind
// the lambda and hope for the best.
return node;
}
private static bool NodeIsExplicitType(SyntaxNode node, SyntaxNode lambda)
{
Debug.Assert(node != null);
Debug.Assert(lambda != null);
Debug.Assert(lambda.IsAnonymousFunction() || lambda.IsQuery());
// UNDONE;
return false;
}
internal static bool IsInAnonymousFunctionOrQuery(int position, SyntaxNode lambdaExpressionOrQueryNode)
{
Debug.Assert(lambdaExpressionOrQueryNode.IsAnonymousFunction() || lambdaExpressionOrQueryNode.IsQuery());
SyntaxToken firstIncluded;
CSharpSyntaxNode body;
switch (lambdaExpressionOrQueryNode.Kind())
{
case SyntaxKind.SimpleLambdaExpression:
SimpleLambdaExpressionSyntax simple = (SimpleLambdaExpressionSyntax)lambdaExpressionOrQueryNode;
firstIncluded = simple.Parameter.Identifier;
body = simple.Body;
break;
case SyntaxKind.ParenthesizedLambdaExpression:
ParenthesizedLambdaExpressionSyntax parenthesized = (ParenthesizedLambdaExpressionSyntax)lambdaExpressionOrQueryNode;
firstIncluded = parenthesized.ParameterList.OpenParenToken;
body = parenthesized.Body;
break;
case SyntaxKind.AnonymousMethodExpression:
AnonymousMethodExpressionSyntax anon = (AnonymousMethodExpressionSyntax)lambdaExpressionOrQueryNode;
firstIncluded = anon.DelegateKeyword;
body = anon.Block;
break;
default:
// OK, so we have some kind of query clause. They all start with a keyword token, so we'll skip that.
firstIncluded = lambdaExpressionOrQueryNode.GetFirstToken().GetNextToken();
return IsBetweenTokens(position, firstIncluded, lambdaExpressionOrQueryNode.GetLastToken().GetNextToken());
}
var bodyStatement = body as StatementSyntax;
var firstExcluded = bodyStatement != null ?
GetFirstExcludedToken(bodyStatement) :
(SyntaxToken)SyntaxNavigator.Instance.GetNextToken(body, predicate: null, stepInto: null);
return IsBetweenTokens(position, firstIncluded, firstExcluded);
}
