protected override CombinedSyntaxNode[] QueryTargetsProtected(CombinedSyntaxNode baseNode)
{
Func <SyntaxNode, bool> match;
if (baseNode.BaseNode is CompilationUnitSyntax)
{
match = FileMemberSyntaxNodeMatcher.Instance.Match;
}
else if (baseNode.BaseNode is NamespaceDeclarationSyntax)
{
match = NamespaceMemberSyntaxNodeMatcher.Instance.Match;
}
else if (baseNode.BaseNode is ClassDeclarationSyntax ||
baseNode.BaseNode is InterfaceDeclarationSyntax)
{
match = ClassMemberSyntaxNodeMatcher.Instance.Match;
}
else if (baseNode.BaseNode is StructDeclarationSyntax)
{
match = StructMemberSyntaxNodeMatcher.Instance.Match;
}
else
{
throw new ArgumentException("Unsupported node type", nameof(baseNode));
}
CombinedSyntaxNode[] members = baseNode.BaseNode.ChildNodes()
.Where(match)
.GroupBy(x => x.Kind())
.Select(x => new CombinedSyntaxNode(x.First()))
.ToArray();
return(members);
}
public MethodBodyState(LocalContext context, CombinedSyntaxNode contextNode)
: base(context, contextNode)
{
if (!MethodBodySyntaxNodeMatcher.Instance.Match(contextNode.BaseNode))
{
throw new ArgumentException("Unsupported node type.", nameof(contextNode));
}
}
public MethodMemberSiblingState(CombinedSyntaxNode baseNode) : base(baseNode)
{
if (!MethodMemberParentSyntaxNodeMatcher.Instance.Match(baseNode.BaseNode))
{
throw new ArgumentException(
"The provided base node is not a method body.",
nameof(baseNode));
}
}
public AutoPropertyDeclarationState(LocalContext context, CombinedSyntaxNode contextNode)
: base(context, contextNode)
{
if (contextNode.MixedNode.GetType() != typeof(AutoPropertyDeclarationSyntax))
{
throw new ArgumentException(
$"Unsupported base node type for {nameof(AutoPropertyDeclarationState)}");
}
}
public bool Match(CombinedSyntaxNode node)
{
if (node.IsVirtual)
{
return(VirtualMethodMembers.Contains(node.MixedNode.GetType()));
}
return(this.Match(node.BaseNode));
}
public CatchClauseState(LocalContext context, CombinedSyntaxNode contextNode)
: base(context, contextNode)
{
if (contextNode.MixedNode.GetType() != typeof(CatchClauseSyntax))
{
throw new ArgumentException(
$"Unsupported context node for {nameof(CatchClauseState)}.");
}
}
protected MethodMemberStateBase(LocalContext context, CombinedSyntaxNode contextNode)
: base(context, contextNode)
{
if (!MethodMemberSyntaxNodeMatcher.Instance.Match(contextNode.BaseNode))
{
throw new ArgumentException(
"The provided context node is not a member of a method declaration.",
nameof(contextNode));
}
}
public TryMemberSiblingState(CombinedSyntaxNode baseNode) : base(baseNode)
{
if (!(baseNode.BaseNode is TryStatementSyntax))
{
throw new ArgumentException(
"The provided base node is not supported by " +
$"{nameof(TryMemberSiblingState)}",
nameof(baseNode));;;
}
}
public IfMemberSiblingState(CombinedSyntaxNode baseNode) : base(baseNode)
{
if (baseNode.MixedNode.GetType() != typeof(IfStatementSyntax))
{
throw new ArgumentException(
"The provided base node can not be used for " +
$"{nameof(IfMemberSiblingState)}. " +
$"The actual mixed node type is {baseNode.MixedNode.GetType()}.",
nameof(baseNode));
}
}
public ElseBodyState(LocalContext context, CombinedSyntaxNode contextNode)
: base(context, contextNode)
{
if (contextNode.MixedNode.GetType() != typeof(ElseBodySyntax))
{
throw new ArgumentException(
$"Unsupported context node for {nameof(ElseBodyState)}. " +
$"Actual node type: {contextNode.MixedNode.GetType()}.");
}
targets = new[] { contextNode };
}
protected override CombinedSyntaxNode[] QueryTargetsProtected(CombinedSyntaxNode root)
{
return(root.BaseNode
?.ChildNodes()
.Where(x => !(x is TypeSyntax))
.QueryVirtualAndCombine(MethodBodyVirtualQuery.Instance)
.Where(MethodMemberSyntaxNodeMatcher.Instance.Match)
.GroupBy(x => x.MixedNode.GetType())
.Select(x => x.First())
.ToArray()
?? Array.Empty <CombinedSyntaxNode>());
}
protected LocalContextState(LocalContext context, CombinedSyntaxNode contextNode)
: base(context, contextNode)
{
// it was introduced as an optimization but caused
// an error when TNode was set to the base SyntaxNode
// for some states.
//if (!(context.State is LocalContextState<TNode, T>))
//{
// this.SiblingState = this.InitSiblingState();
//}
this.SiblingState = this.InitSiblingState();
}
public FinallyClauseState(LocalContext context, CombinedSyntaxNode contextNode)
: base(context, contextNode)
{
if (contextNode.MixedNode.GetType() != typeof(FinallyClauseSyntax))
{
throw new ArgumentException(
$"Unsupported context node for {nameof(FinallyClauseState)}.");
}
targetNodes = new[] { contextNode };
}
public ElseClauseState(LocalContext context, CombinedSyntaxNode contextNode)
: base(context, contextNode)
{
if (contextNode.MixedNode.GetType() != typeof(ElseClauseSyntax))
{
throw new ArgumentException(
$"The provided context node is not supported by {nameof(ElseClauseState)}.\"" +
$"Actual: {contextNode.MixedNode.GetType()}.",
nameof(contextNode));
}
targets = new[] { contextNode };
}
public TryBodyState(LocalContext context, CombinedSyntaxNode contextNode)
: base(context, contextNode)
{
if (contextNode.MixedNode.GetType() != typeof(TryBodySyntax))
{
throw new ArgumentException(
$"The provided context node is not supported by {nameof(TryBodyState)}.",
nameof(contextNode));
}
// try statement can only have a single try block
targets = new[] { contextNode };
}
public TryMemberStateBase(LocalContext context, CombinedSyntaxNode contextNode)
: base(context, contextNode)
{
Type mixedType = contextNode.MixedNode.GetType();
if (mixedType != typeof(TryBodySyntax) &&
mixedType != typeof(CatchClauseSyntax) &&
mixedType != typeof(FinallyClauseSyntax))
{
throw new ArgumentException(
$"Unsupported context node for {this.GetType()}.");
}
}
public ClassMemberSiblingState(CombinedSyntaxNode baseNode) : base(baseNode)
{
Type baseNodeType = baseNode.BaseNode.GetType();
if (baseNodeType != typeof(ClassDeclarationSyntax) &&
baseNodeType != typeof(StructDeclarationSyntax) &&
baseNodeType != typeof(InterfaceDeclarationSyntax))
{
throw new ArgumentException(
"Only base nodes of type class, struct or interface " +
"are supported by this state.",
nameof(baseNode));
}
}
public IfMemberStateBase(LocalContext context, CombinedSyntaxNode contextNode)
: base(context, contextNode)
{
Type mixedType = contextNode.MixedNode.GetType();
if (mixedType != typeof(IfConditionSyntax) &&
mixedType != typeof(IfBodySyntax) &&
mixedType != typeof(ElseClauseSyntax) &&
mixedType != typeof(ElseBodySyntax))
{
throw new ArgumentException(
$"Unsupported context node for {this.GetType()}.");
}
}
protected override CombinedSyntaxNode[] QueryTargetsProtected(CombinedSyntaxNode baseNode)
{
CombinedSyntaxNode[] members = baseNode.BaseNode.ChildNodes()
.Where(x =>
x is BlockSyntax ||
x is FinallyClauseSyntax ||
x is CatchClauseSyntax)
.GroupBy(x => x.Kind())
.Select(x => x.First())
.QueryVirtualAndCombine(
TryBodyVirtualQuery.Instance)
.ToArray();
return(members);
}
protected PropOrEventClassMemberStateBase(
LocalContext context,
CombinedSyntaxNode contextNode)
: base(context, contextNode)
{
Type nodeType = contextNode.BaseNode.GetType();
if (nodeType != typeof(PropertyDeclarationSyntax) &&
nodeType != typeof(EventDeclarationSyntax) &&
nodeType != typeof(EventFieldDeclarationSyntax))
{
throw new ArgumentException(
"The provided node is not a base node " +
$"for {nameof(PropOrEventClassMemberStateBase<T>)}");
}
}
public NestedBlockState(LocalContext context, CombinedSyntaxNode contextNode)
: base(context, contextNode)
{
if (contextNode.MixedNode.GetType() != typeof(NestedBlockSyntax))
{
throw new ArgumentException(
$"The provided node is not of type {nameof(NestedBlockSyntax)}.",
nameof(contextNode));
}
if (!NestedBlockSyntaxNodeMatcher.Instance.Match(contextNode.BaseNode))
{
throw new ArgumentException(
"The provided base node is not a nested block",
nameof(contextNode));
}
}
private void PerformJumpAction(Action <CombinedSyntaxNode?> jumpAction)
{
_ = this.SiblingState ?? throw new NullReferenceException(
"Sibling state should be initialized before jumping to a sibling.");
this.SiblingState.QueryTargets();
if (!this.SiblingState.HasTargets)
{
return;
}
jumpAction(this.Context.State.ActiveNode);
CombinedSyntaxNode target = this.SiblingState.Target;
this.JumpToTarget(target, true);
}
protected override CombinedSyntaxNode[] QueryTargetsProtected(CombinedSyntaxNode root)
{
if (!(root.BaseNode is IfStatementSyntax ifRoot))
{
throw new InvalidOperationException(
$"The provided root is not {nameof(IfStatementSyntax)}.");
}
var members = new List <SyntaxNode>();
members.AddIfNotNull(ifRoot.Condition);
members.AddIfNotNull(ifRoot.Statement);
members.AddIfNotNull(ifRoot.Else);
return(members.QueryVirtualAndCombine(
IfConditionVirtualQuery.Instance,
IfBodyVirtualQuery.Instance,
ElseBodyVirtualQuery.Instance)
.ToArray());
}
protected override CombinedSyntaxNode[] QueryTargetsProtected(CombinedSyntaxNode root)
{
if (root.MixedNode is IfConditionSyntax condition)
{
return(new CombinedSyntaxNode[]
{
condition.Expression.QueryVirtualAndCombine(
NestedBlockVirtualQuery.Instance)
});
}
return(root.BaseNode
?.ChildNodes()
.QueryVirtualAndCombine(VirtualQueryExtensions.GetAllSupportedQueries())
.Where(MethodBodyMemberSyntaxNodeMatcher.Instance.Match)
.GroupBy(x => x.MixedNode.GetType())
.Select(x => x.First())
.ToArray()
?? Array.Empty <CombinedSyntaxNode>());
}
public MethodBodyMemberSiblingState(CombinedSyntaxNode baseNode) : base(baseNode)
{
Type mixedNodeType = baseNode.MixedNode.GetType();
if (mixedNodeType != typeof(MethodBodyDeclarationSyntax) &&
mixedNodeType != typeof(NestedBlockSyntax) &&
mixedNodeType != typeof(IfConditionSyntax))
{
throw new ArgumentException(
"The provided node is not a method body nor a nested block. " +
$"Actual node type is {mixedNodeType}.");
}
if (!MethodBodySyntaxNodeMatcher.Instance.Match(baseNode.BaseNode) &&
!baseNode.BaseNode.IsContainer())
{
throw new ArgumentException(
"The provided base node is not a method body.",
nameof(baseNode));
}
}
protected override CombinedSyntaxNode[] QueryTargetsProtected(CombinedSyntaxNode baseNode)
{
CombinedSyntaxNode[] members = baseNode.BaseNode.ChildNodes()
.Where(ClassMemberSyntaxNodeMatcher.Instance.Match)
.GroupBy(x =>
{
SyntaxKind kind = x.Kind();
// "patch" event-field to treat it as a general event
// it allows to treat them as the same sibling kind
return(kind == SyntaxKind.EventFieldDeclaration
? SyntaxKind.EventDeclaration
: kind);
})
.Select(x => x.First())
.QueryVirtualAndCombine(
AutoPropertyVirtualQuery.Instance,
ReadOnlyPropertyVirtualQuery.Instance)
.ToArray();
return(members);
}
protected override CombinedSyntaxNode[] QueryTargetsProtected(CombinedSyntaxNode root)
{
return(Array.Empty <CombinedSyntaxNode>());
}
protected ClassMemberStateBase(LocalContext context, CombinedSyntaxNode contextNode)
: base(context, contextNode)
{
}
public ClassDeclarationState(LocalContext context, CombinedSyntaxNode contextNode)
: base(context, contextNode)
{
}
public ForEachStatementState(LocalContext context, CombinedSyntaxNode contextNode)
: base(context, contextNode)
{
}
