/// <summary>
/// Returns true if the node is the object of an element access expression.
/// </summary>
public static bool IsIndexed(ExpressionSyntax node)
{
node = (ExpressionSyntax)SyntaxFactory.GetStandaloneExpression(node);
var indexer = node.Parent as ElementAccessExpressionSyntax;
return(indexer != null && indexer.Expression == node);
}
/// <summary>
/// Returns true if a node is in a tree location that is expected to be either a namespace or type
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public static bool IsInNamespaceOrTypeContext(ExpressionSyntax node)
{
if (node != null)
{
node = (ExpressionSyntax)SyntaxFactory.GetStandaloneExpression(node);
var parent = node.Parent;
if (parent != null)
{
switch (parent.Kind())
{
case UsingDirective:
return(((UsingDirectiveSyntax)parent).Name == node);
case QualifiedName:
// left of QN is namespace or type. Note: when you have "a.b.c()", then
// "a.b" is not a qualified name, it is a member access expression.
// Qualified names are only parsed when the parser knows it's a type only
// context.
return(((QualifiedNameSyntax)parent).Left == node);
default:
return(IsInTypeOnlyContext(node));
}
}
}
return(false);
}
/// <summary>
/// Returns true if the node is the object of an invocation expression.
/// </summary>
public static bool IsInvoked(ExpressionSyntax node)
{
node = (ExpressionSyntax)SyntaxFactory.GetStandaloneExpression(node);
var inv = node.Parent as InvocationExpressionSyntax;
return(inv != null && inv.Expression == node);
}
/// <summary>
/// Returns true if the node is in a tree location that is expected to be a type
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public static bool IsInTypeOnlyContext(ExpressionSyntax node)
{
node = SyntaxFactory.GetStandaloneExpression(node);
var parent = node.Parent;
if (parent != null)
{
switch (parent.Kind())
{
case Attribute:
return(((AttributeSyntax)parent).Name == node);
case ArrayType:
return(((ArrayTypeSyntax)parent).ElementType == node);
case PointerType:
return(((PointerTypeSyntax)parent).ElementType == node);
case PredefinedType:
return(true);
case NullableType:
return(((NullableTypeSyntax)parent).ElementType == node);
case TypeArgumentList:
// all children of GenericNames are type arguments
return(true);
case CastExpression:
return(((CastExpressionSyntax)parent).Type == node);
case ObjectCreationExpression:
return(((ObjectCreationExpressionSyntax)parent).Type == node);
case StackAllocArrayCreationExpression:
return(((StackAllocArrayCreationExpressionSyntax)parent).Type == node);
case FromClause:
return(((FromClauseSyntax)parent).Type == node);
case JoinClause:
return(((JoinClauseSyntax)parent).Type == node);
case VariableDeclaration:
return(((VariableDeclarationSyntax)parent).Type == node);
case ForEachStatement:
return(((ForEachStatementSyntax)parent).Type == node);
case CatchDeclaration:
return(((CatchDeclarationSyntax)parent).Type == node);
case AsExpression:
case IsExpression:
return(((BinaryExpressionSyntax)parent).Right == node);
case TypeOfExpression:
return(((TypeOfExpressionSyntax)parent).Type == node);
case SizeOfExpression:
return(((SizeOfExpressionSyntax)parent).Type == node);
case DefaultExpression:
return(((DefaultExpressionSyntax)parent).Type == node);
case RefValueExpression:
return(((RefValueExpressionSyntax)parent).Type == node);
case RefType:
return(((RefTypeSyntax)parent).Type == node);
case Parameter:
return(((ParameterSyntax)parent).Type == node);
case TypeConstraint:
return(((TypeConstraintSyntax)parent).Type == node);
case MethodDeclaration:
return(((MethodDeclarationSyntax)parent).ReturnType == node);
case IndexerDeclaration:
return(((IndexerDeclarationSyntax)parent).Type == node);
case OperatorDeclaration:
return(((OperatorDeclarationSyntax)parent).ReturnType == node);
case ConversionOperatorDeclaration:
return(((ConversionOperatorDeclarationSyntax)parent).Type == node);
case PropertyDeclaration:
return(((PropertyDeclarationSyntax)parent).Type == node);
case DelegateDeclaration:
return(((DelegateDeclarationSyntax)parent).ReturnType == node);
case EventDeclaration:
return(((EventDeclarationSyntax)parent).Type == node);
case LocalFunctionStatement:
return(((LocalFunctionStatementSyntax)parent).ReturnType == node);
case SimpleBaseType:
return(true);
case CrefParameter:
return(true);
case ConversionOperatorMemberCref:
return(((ConversionOperatorMemberCrefSyntax)parent).Type == node);
case ExplicitInterfaceSpecifier:
// #13.4.1 An explicit member implementation is a method, property, event or indexer
// declaration that references a fully qualified interface member name.
// A ExplicitInterfaceSpecifier represents the left part (QN) of the member name, so it
// should be treated like a QualifiedName.
return(((ExplicitInterfaceSpecifierSyntax)parent).Name == node);
case DeclarationPattern:
return(((DeclarationPatternSyntax)parent).Type == node);
case TupleElement:
return(((TupleElementSyntax)parent).Type == node);
case DeclarationExpression:
return(((DeclarationExpressionSyntax)parent).Type == node);
case IncompleteMember:
return(((IncompleteMemberSyntax)parent).Type == node);
}
}
return(false);
}
/// <summary>
/// Returns true if the node is in a tree location that is expected to be a type
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public static bool IsInTypeOnlyContext(ExpressionSyntax node)
{
node = (ExpressionSyntax)SyntaxFactory.GetStandaloneExpression(node);
var parent = node.Parent;
if (parent != null)
{
switch (parent.Kind)
{
case SyntaxKind.Annotation:
return(((AnnotationSyntax)parent).Name == node);
case SyntaxKind.ArrayType:
return(((ArrayTypeSyntax)parent).ElementType == node);
case SyntaxKind.PredefinedType:
return(true);
//case SyntaxKind.NullableType:
// return ((NullableTypeSyntax)parent).ElementType == node;
case SyntaxKind.TypeArgumentList:
// all children of GenericNames are type arguments
return(true);
case SyntaxKind.CastExpression:
return(((CastExpressionSyntax)parent).Type == node);
case SyntaxKind.ObjectCreationExpression:
return(((ObjectCreationExpressionSyntax)parent).Type == node);
case SyntaxKind.VariableDeclaration:
return(((VariableDeclarationSyntax)parent).Type == node);
case SyntaxKind.CatchDeclaration:
return(((CatchDeclarationSyntax)parent).Type == node);
case SyntaxKind.InstanceOfExpression:
return(((BinaryExpressionSyntax)parent).Right == node);
case SyntaxKind.DefaultExpression:
return(((DefaultExpressionSyntax)parent).Type == node);
case SyntaxKind.Parameter:
return(((ParameterSyntax)parent).Type == node);
case SyntaxKind.TypeConstraint:
return(((TypeConstraintSyntax)parent).Type == node);
case SyntaxKind.MethodDeclaration:
return(((MethodDeclarationSyntax)parent).ReturnType == node);
case SyntaxKind.ImplementsListClause:
return(true); // children of BaseListSyntax are only types
case SyntaxKind.CrefParameter:
return(true);
}
}
return(false);
}