/// <summary>
/// Parse a variable.
/// <see cref="VariableNode" />:
/// $Name
/// </summary>
private void ParseVariableName(bool isReference)
{
ISyntaxToken start = _reader.Token;
SyntaxClassificationKind classificationKind = isReference
? SyntaxClassificationKind.VariableReference
: SyntaxClassificationKind.VariableIdentifier;
if (_reader.Kind == TokenKind.Dollar)
{
MoveNext();
_classifications.AddClassification(
_reader.Kind == TokenKind.Name
? classificationKind
: SyntaxClassificationKind.Error,
new Location(start, _reader.Token));
}
else
{
_classifications.AddClassification(
SyntaxClassificationKind.Error,
_reader.Token);
}
MoveNext();
}
public SyntaxClassification(SyntaxClassificationKind kind, int start, int length)
{
Kind = kind;
Start = start;
End = start + length;
Length = length;
}
/// <summary>
/// Parses the <see cref="OperationType" />.
/// </summary>
private void ParseOperationType()
{
SyntaxClassificationKind kind = (_reader.Kind == TokenKind.Name ||
_reader.Value.SequenceEqual(GraphQLKeywords.Query) ||
_reader.Value.SequenceEqual(GraphQLKeywords.Mutation) ||
_reader.Value.SequenceEqual(GraphQLKeywords.Subscription))
? SyntaxClassificationKind.OperationKind
: SyntaxClassificationKind.Error;
_classifications.AddClassification(kind, _reader.Token);
MoveNext();
}
private bool Skip(
SyntaxClassificationKind classificationKind,
TokenKind tokenKind)
{
if (_reader.Kind == tokenKind)
{
_classifications.AddClassification(
classificationKind,
_reader.Token);
MoveNext();
return(true);
}
return(false);
}
private bool SkipKeyword(
SyntaxClassificationKind classificationKind,
ReadOnlySpan <char> keyword)
{
if (_reader.Kind == TokenKind.Name &&
_reader.Value.SequenceEqual(keyword))
{
_classifications.AddClassification(
classificationKind,
_reader.Token);
MoveNext();
return(true);
}
return(false);
}
/// <summary>
/// Parses input value definitions.
/// <see cref="InputValueDefinitionNode" />:
/// Description? Name : Type DefaultValue? Directives[isConstant=true]?
/// </summary>
private void ParseInputValueDefinition(
SyntaxClassificationKind classificationKind)
{
ParseDescription();
ParseName(classificationKind);
ParseColon();
ParseTypeReference();
if (SkipEqual())
{
ParseValueLiteral(true);
}
ParseDirectives(true);
}
private void ParseName(SyntaxClassificationKind kind)
{
if (_reader.Kind == TokenKind.Name)
{
_classifications.AddClassification(
kind,
_reader.Token);
}
else
{
_classifications.AddClassification(
SyntaxClassificationKind.Error,
_reader.Token);
}
MoveNext();
}
private void ParseStringLiteral(
SyntaxClassificationKind kind = SyntaxClassificationKind.StringLiteral)
{
if (_isString[(int)_reader.Kind])
{
_classifications.AddClassification(
kind,
_reader.Token);
}
else
{
_classifications.AddClassification(
SyntaxClassificationKind.Error,
_reader.Token);
}
MoveNext();
}
private void Expect(
SyntaxClassificationKind classificationKind,
TokenKind tokenKind)
{
if (_reader.Skip(tokenKind, out ISyntaxToken? token))
{
_classifications.AddClassification(
classificationKind,
token);
}
else
{
_classifications.AddClassification(
SyntaxClassificationKind.Error,
_reader.Token);
MoveNext();
}
}
private void ParseKeyword(
SyntaxClassificationKind classificationKind,
ReadOnlySpan <char> keyword)
{
if (_reader.Kind == TokenKind.Name &&
_reader.Value.SequenceEqual(keyword))
{
_classifications.AddClassification(
classificationKind,
_reader.Token);
}
else
{
_classifications.AddClassification(
SyntaxClassificationKind.Error,
_reader.Token);
}
MoveNext();
}
public static void AddClassification(
this ICollection <SyntaxClassification> classifications,
SyntaxClassificationKind kind,
ISyntaxToken token) =>
classifications.Add(new SyntaxClassification(
kind, token.Start, token.Length));
public static void AddClassification(
this ICollection <SyntaxClassification> classifications,
SyntaxClassificationKind kind,
Location location) =>
classifications.Add(new SyntaxClassification(
kind, location.Start, location.Length));
