protected virtual ISyntaxVisitorAction Leave(
IValueNode node,
ISyntaxVisitorContext context) =>
DefaultAction;
protected virtual ISyntaxVisitorAction Enter(
ObjectValueNode node,
ISyntaxVisitorContext context) =>
DefaultAction;
protected virtual ISyntaxVisitorAction Leave(
ObjectFieldNode node,
ISyntaxVisitorContext context) =>
DefaultAction;
protected virtual ISyntaxVisitorAction Enter(
SelectionSetNode node,
ISyntaxVisitorContext context) =>
DefaultAction;
protected virtual ISyntaxVisitorAction Enter(
FragmentDefinitionNode node,
ISyntaxVisitorContext context) =>
DefaultAction;
protected virtual ISyntaxVisitorAction Leave(
SchemaExtensionNode node,
ISyntaxVisitorContext context) =>
DefaultAction;
protected override ISyntaxVisitorAction Leave(
ISyntaxNode node,
ISyntaxVisitorContext context)
{
switch (node.Kind)
{
case SyntaxKind.Name:
return(Leave((NameNode)node, context));
case SyntaxKind.Document:
return(Leave((DocumentNode)node, context));
case SyntaxKind.OperationDefinition:
return(Leave((OperationDefinitionNode)node, context));
case SyntaxKind.VariableDefinition:
return(Leave((VariableDefinitionNode)node, context));
case SyntaxKind.Variable:
return(Leave((VariableNode)node, context));
case SyntaxKind.SelectionSet:
return(Leave((SelectionSetNode)node, context));
case SyntaxKind.Field:
return(Leave((FieldNode)node, context));
case SyntaxKind.Argument:
return(Leave((ArgumentNode)node, context));
case SyntaxKind.FragmentSpread:
return(Leave((FragmentSpreadNode)node, context));
case SyntaxKind.InlineFragment:
return(Leave((InlineFragmentNode)node, context));
case SyntaxKind.FragmentDefinition:
return(Leave((FragmentDefinitionNode)node, context));
case SyntaxKind.Directive:
return(Leave((DirectiveNode)node, context));
case SyntaxKind.NamedType:
return(Leave((NamedTypeNode)node, context));
case SyntaxKind.ListType:
return(Leave((ListTypeNode)node, context));
case SyntaxKind.NonNullType:
return(Leave((NonNullTypeNode)node, context));
case SyntaxKind.ListValue:
return(Leave((ListValueNode)node, context));
case SyntaxKind.ObjectValue:
return(Leave((ObjectValueNode)node, context));
case SyntaxKind.ObjectField:
return(Leave((ObjectFieldNode)node, context));
case SyntaxKind.BooleanValue:
case SyntaxKind.EnumValue:
case SyntaxKind.FloatValue:
case SyntaxKind.IntValue:
case SyntaxKind.NullValue:
case SyntaxKind.StringValue:
return(Leave((IValueNode)node, context));
case SyntaxKind.SchemaDefinition:
return(Leave((SchemaDefinitionNode)node, context));
case SyntaxKind.OperationTypeDefinition:
return(Leave((OperationTypeDefinitionNode)node, context));
case SyntaxKind.ScalarTypeDefinition:
return(Leave((ScalarTypeDefinitionNode)node, context));
case SyntaxKind.ObjectTypeDefinition:
return(Leave((ObjectTypeDefinitionNode)node, context));
case SyntaxKind.FieldDefinition:
return(Leave((FieldDefinitionNode)node, context));
case SyntaxKind.InputValueDefinition:
return(Leave((InputValueDefinitionNode)node, context));
case SyntaxKind.InterfaceTypeDefinition:
return(Leave((InterfaceTypeDefinitionNode)node, context));
case SyntaxKind.UnionTypeDefinition:
return(Leave((UnionTypeDefinitionNode)node, context));
case SyntaxKind.EnumTypeDefinition:
return(Leave((EnumTypeDefinitionNode)node, context));
case SyntaxKind.EnumValueDefinition:
return(Leave((EnumValueDefinitionNode)node, context));
case SyntaxKind.InputObjectTypeDefinition:
return(Leave((InputObjectTypeDefinitionNode)node, context));
case SyntaxKind.DirectiveDefinition:
return(Leave((DirectiveDefinitionNode)node, context));
case SyntaxKind.SchemaExtension:
return(Leave((SchemaExtensionNode)node, context));
case SyntaxKind.ScalarTypeExtension:
return(Leave((ScalarTypeExtensionNode)node, context));
case SyntaxKind.ObjectTypeExtension:
return(Leave((ObjectTypeExtensionNode)node, context));
case SyntaxKind.InterfaceTypeExtension:
return(Leave((InterfaceTypeExtensionNode)node, context));
case SyntaxKind.UnionTypeExtension:
return(Leave((UnionTypeExtensionNode)node, context));
case SyntaxKind.EnumTypeExtension:
return(Leave((EnumTypeExtensionNode)node, context));
case SyntaxKind.InputObjectTypeExtension:
return(Leave((InputObjectTypeExtensionNode)node, context));
default:
throw new NotSupportedException(node.GetType().FullName);
}
}
protected virtual IEnumerable <ISyntaxNode> GetNodes(
ISyntaxNode node,
ISyntaxVisitorContext context) =>
node.GetNodes();
protected virtual ISyntaxVisitorContext OnBeforeEnter(
ISyntaxNode node,
ISyntaxNode?parent,
IReadOnlyList <ISyntaxNode> ancestors,
ISyntaxVisitorContext context) =>
context;
protected override ISyntaxVisitorAction Enter(
ISyntaxNode node,
ISyntaxVisitorContext context) =>
_enter(node, context);
protected override ISyntaxVisitorAction Leave(
ISyntaxNode node,
ISyntaxVisitorContext context) =>
_leave(node, context);
protected virtual ISyntaxVisitorAction Enter(
EnumTypeExtensionNode node,
ISyntaxVisitorContext context) =>
DefaultAction;
protected virtual ISyntaxVisitorAction Enter(
InputObjectTypeDefinitionNode node,
ISyntaxVisitorContext context) =>
DefaultAction;
protected virtual ISyntaxVisitorAction Enter(
OperationTypeDefinitionNode node,
ISyntaxVisitorContext context) =>
DefaultAction;
protected virtual ISyntaxVisitorAction Leave(
InterfaceTypeDefinitionNode node,
ISyntaxVisitorContext context) =>
DefaultAction;
protected ISyntaxVisitorContext OnAfterLeave(
ISyntaxNode node,
ISyntaxNode?parent,
IReadOnlyList <ISyntaxNode> ancestors,
ISyntaxVisitorContext context) =>
context;
protected virtual ISyntaxVisitorAction Leave(
DirectiveDefinitionNode node,
ISyntaxVisitorContext context) =>
DefaultAction;
public ISyntaxVisitorAction Visit(
ISyntaxNode node,
ISyntaxVisitorContext context)
{
var levels = new List <List <ISyntaxNode> >();
List <ISyntaxNode> ancestors = _listPool.Get();
List <ISyntaxNode> root = _listPool.Get();
ISyntaxVisitorContext localContext = context;
int index = 0;
root.Push(node);
levels.Push(root);
ISyntaxNode? parent = null;
ISyntaxVisitorAction result = DefaultAction;
while (levels.Count > 0)
{
bool isLeaving = levels[index].Count == 0;
ISyntaxNode?current;
if (isLeaving)
{
if (index == 0)
{
break;
}
_listPool.Return(levels.Pop());
current = ancestors.Pop();
ancestors.TryPeek(out parent);
result = Leave(current, localContext);
localContext = OnAfterLeave(current, parent, ancestors, localContext);
index--;
}
else
{
current = levels[index].Pop();
localContext = OnBeforeEnter(current, parent, ancestors, localContext);
result = Enter(current, localContext);
if (result is ContinueSyntaxVisitorAction)
{
List <ISyntaxNode> nextLevel = _listPool.Get();
nextLevel.AddRange(GetNodes(current, localContext));
levels.Push(nextLevel);
}
else if (result is SkipSyntaxVisitorAction)
{
levels.Push(_empty);
}
parent = current;
ancestors.Push(current);
index++;
}
if (result is BreakSyntaxVisitorAction)
{
break;
}
}
if (levels.Count > 0)
{
for (int i = 0; i < levels.Count; i++)
{
_listPool.Return(levels[i]);
}
}
_listPool.Return(ancestors);
return(result);
}
protected virtual ISyntaxVisitorAction Leave(
InputObjectTypeExtensionNode node,
ISyntaxVisitorContext context) =>
DefaultAction;
protected virtual ISyntaxVisitorAction Leave(
ArgumentNode node,
ISyntaxVisitorContext context) =>
DefaultAction;
protected virtual ISyntaxVisitorAction Enter(
VariableDefinitionNode node,
ISyntaxVisitorContext context) =>
DefaultAction;
protected virtual ISyntaxVisitorAction Leave(
FragmentSpreadNode node,
ISyntaxVisitorContext context) =>
DefaultAction;
protected virtual ISyntaxVisitorAction Enter(
InlineFragmentNode node,
ISyntaxVisitorContext context) =>
DefaultAction;
protected virtual ISyntaxVisitorAction Leave(
NonNullTypeNode node,
ISyntaxVisitorContext context) =>
DefaultAction;
protected virtual ISyntaxVisitorAction Enter(
DirectiveNode node,
ISyntaxVisitorContext context) =>
DefaultAction;
protected virtual ISyntaxVisitorAction Enter(
NamedTypeNode node,
ISyntaxVisitorContext context) =>
DefaultAction;
