/// <summary>
/// Parses a type reference.
/// <see cref="ITypeNode" />:
/// - NamedType
/// - ListType
/// - NonNullType
/// </summary>
/// <param name="context">The parser context.</param>
private static ITypeNode ParseTypeReference(ParserContext context)
{
SyntaxToken start = context.Current;
ITypeNode type;
Location location;
if (context.Skip(TokenKind.LeftBracket))
{
type = ParseTypeReference(context);
context.ExpectRightBracket();
location = context.CreateLocation(start);
type = new ListTypeNode(location, type);
}
else
{
type = ParseNamedType(context);
}
if (context.Skip(TokenKind.Bang))
{
if (type is INullableType nt)
{
return(new NonNullTypeNode
(
context.CreateLocation(start),
nt
));
}
context.Unexpected(context.Current.Previous);
}
return(type);
}
public Node ListType()
{
var listType = new ListTypeNode()
{
AnchorToken = Expect(TokenCategory.LIST)
};
Expect(TokenCategory.OF);
listType.Add(SimpleType());
return(listType);
}
protected sealed override ISyntaxVisitorAction Enter(
ISyntaxNode node,
ISyntaxVisitorContext context)
{
return(node switch
{
DocumentNode n => Enter(n, context),
OperationDefinitionNode n => Enter(n, context),
VariableDefinitionNode n => Enter(n, context),
VariableNode n => Enter(n, context),
SelectionSetNode n => Enter(n, context),
FieldNode n => Enter(n, context),
ArgumentNode n => Enter(n, context),
FragmentSpreadNode n => Enter(n, context),
InlineFragmentNode n => Enter(n, context),
FragmentDefinitionNode n => Enter(n, context),
DirectiveNode n => Enter(n, context),
NamedTypeNode n => Enter(n, context),
ListTypeNode n => Enter(n, context),
NonNullTypeNode n => Enter(n, context),
ListValueNode n => Enter(n, context),
ObjectValueNode n => Enter(n, context),
ObjectFieldNode n => Enter(n, context),
IValueNode n => Enter(n, context),
SchemaDefinitionNode n => Enter(n, context),
OperationTypeDefinitionNode n => Enter(n, context),
ScalarTypeDefinitionNode n => Enter(n, context),
ObjectTypeDefinitionNode n => Enter(n, context),
FieldDefinitionNode n => Enter(n, context),
InputValueDefinitionNode n => Enter(n, context),
InterfaceTypeDefinitionNode n => Enter(n, context),
UnionTypeDefinitionNode n => Enter(n, context),
EnumTypeDefinitionNode n => Enter(n, context),
EnumValueDefinitionNode n => Enter(n, context),
InputObjectTypeDefinitionNode n => Enter(n, context),
DirectiveDefinitionNode n => Enter(n, context),
SchemaExtensionNode n => Enter(n, context),
ScalarTypeExtensionNode n => Enter(n, context),
ObjectTypeExtensionNode n => Enter(n, context),
InterfaceTypeExtensionNode n => Enter(n, context),
UnionTypeExtensionNode n => Enter(n, context),
EnumTypeExtensionNode n => Enter(n, context),
InputObjectTypeExtensionNode n => Enter(n, context),
_ => throw new NotSupportedException()
});
/// <summary>
/// Parses a type reference.
/// <see cref="ITypeNode" />:
/// - NamedType
/// - ListType
/// - NonNullType
/// </summary>
/// <param name="context">The parser context.</param>
private ITypeNode ParseTypeReference()
{
ITypeNode type;
Location location;
if (_reader.Kind == TokenKind.LeftBracket)
{
TokenInfo start = Start();
MoveNext();
type = ParseTypeReference();
ExpectRightBracket();
location = CreateLocation(in start);
type = new ListTypeNode(location, type);
}
else
{
type = ParseNamedType();
}
if (_reader.Kind == TokenKind.Bang)
{
if (type is INullableTypeNode nt)
{
TokenInfo start = Start();
MoveNext();
location = CreateLocation(in start);
return(new NonNullTypeNode
(
location,
nt
));
}
Unexpected(TokenKind.Bang);
}
return(type);
}
private IDictionary <string, object?> CreateTypeDto(
ITypeNode type,
IDictionary <string, TypeKind> typeKinds)
{
return(type switch
{
NonNullTypeNode nnt => new Dictionary <string, object?>
{
{ "kind", TypeKind.NonNull }, { "ofType", CreateTypeDto(nnt.Type, typeKinds) },
},
ListTypeNode lt => new Dictionary <string, object?>
{
{ "kind", TypeKind.List }, { "ofType", CreateTypeDto(lt.Type, typeKinds) },
},
NamedTypeNode nt => new Dictionary <string, object?>
{
{ "kind", typeKinds[nt.Name.Value] }, { "name", nt.Name.Value },
},
_ => throw new InvalidOperationException("Invalid Type Structure.")
});
//-----------------------------------------------------------
public TypeG Visit(ListTypeNode node)
{
dynamic listType;
Console.WriteLine(node.AnchorToken.Category);
switch (node.AnchorToken.Lexeme)
{
case "integer":
return(TypeG.INTEGER_LIST);
case "string":
return(TypeG.STRING_LIST);
case "boolean":
return(TypeG.BOOLEAN_LIST);
default:
throw new Exception($"Type {node} has no equivalent list type");
}
return(listType);
}
protected virtual ISyntaxVisitorAction Enter(
ListTypeNode node,
ISyntaxVisitorContext context) =>
DefaultAction;
protected virtual ISyntaxVisitorAction Leave(
ListTypeNode node,
TContext context) =>
DefaultAction;
protected override void VisitListType(
ListTypeNode node,
TContext context)
{
VisitType(node.Type, context);
}
public void Visit(ListTypeNode node)
{
Visit((dynamic)Node.fromToken(node.AnchorToken));
builder.Append("[]");
}
public Type Visit(ListTypeNode node)
{
return(typeMapper[node.AnchorToken.Category].ToListType());
}
protected override void VisitListType(ListTypeNode node)
{
VisitType(node.Type);
}
protected virtual void VisitListType(ListTypeNode node)
{
}
