internal static SyntaxToken Create(SyntaxKind kind, CSharpSyntaxNode leading, CSharpSyntaxNode trailing)
{
if (kind > LastTokenWithWellKnownText)
{
if (!SyntaxKindFacts.IsAnyToken(kind))
{
throw new ArgumentException(string.Format(CSharpResources.ThisMethodCanOnlyBeUsedToCreateTokens, kind), "kind");
}
return(CreateMissing(kind, leading, trailing));
}
if (leading == null)
{
if (trailing == null)
{
return(TokensWithNoTrivia[(int)kind].Value);
}
else if (trailing == SyntaxFactory.Space)
{
return(TokensWithSingleTrailingSpace[(int)kind].Value);
}
else if (trailing == SyntaxFactory.CarriageReturnLineFeed)
{
return(TokensWithSingleTrailingCRLF[(int)kind].Value);
}
}
if (leading == SyntaxFactory.ElasticZeroSpace && trailing == SyntaxFactory.ElasticZeroSpace)
{
return(TokensWithElasticTrivia[(int)kind].Value);
}
return(new SyntaxTokenWithTrivia(kind, leading, trailing));
}
protected SyntaxToken EatToken(SyntaxKind kind, ErrorCode code, bool reportError = true)
{
Debug.Assert(SyntaxKindFacts.IsAnyToken(kind));
if (this.CurrentToken.Kind != kind)
{
return(CreateMissingToken(kind, code, reportError));
}
else
{
return(this.EatToken());
}
}
protected SyntaxToken EatTokenWithPrejudice(SyntaxKind kind)
{
var token = this.CurrentToken;
Debug.Assert(SyntaxKindFacts.IsAnyToken(kind));
if (token.Kind != kind)
{
token = WithAdditionalDiagnostics(token, this.GetExpectedTokenError(kind, token.Kind));
}
this.MoveToNextToken();
return(token);
}
internal static SyntaxToken Token(CSharpSyntaxNode leading, SyntaxKind kind, string text, string valueText, CSharpSyntaxNode trailing)
{
Debug.Assert(SyntaxKindFacts.IsAnyToken(kind));
Debug.Assert(kind != SyntaxKind.IdentifierToken);
Debug.Assert(kind != SyntaxKind.CharacterLiteralToken);
Debug.Assert(kind != SyntaxKind.NumericLiteralToken);
string defaultText = SyntaxKindFacts.GetText(kind);
return(kind >= SyntaxToken.FirstTokenWithWellKnownText && kind <= SyntaxToken.LastTokenWithWellKnownText && text == defaultText && valueText == defaultText
? Token(leading, kind, trailing)
: SyntaxToken.WithValue(kind, leading, text, valueText, trailing));
}
protected SyntaxToken EatContextualToken(SyntaxKind kind, bool reportError = true)
{
Debug.Assert(SyntaxKindFacts.IsAnyToken(kind));
var contextualKind = this.CurrentToken.ContextualKind;
if (contextualKind != kind)
{
return(CreateMissingToken(kind, contextualKind, reportError));
}
else
{
return(ConvertToKeyword(this.EatToken()));
}
}
//this method is called very frequently
//we should keep it simple so that it can be inlined.
protected SyntaxToken EatToken(SyntaxKind kind)
{
Debug.Assert(SyntaxKindFacts.IsAnyToken(kind));
var ct = this.CurrentToken;
if (ct.Kind == kind)
{
MoveToNextToken();
return(ct);
}
//slow part of EatToken(SyntaxKind kind)
return(CreateMissingToken(kind, this.CurrentToken.Kind, reportError: true));
}
protected SyntaxToken EatToken(SyntaxKind kind, bool reportError)
{
if (reportError)
{
return(EatToken(kind));
}
Debug.Assert(SyntaxKindFacts.IsAnyToken(kind));
if (this.CurrentToken.Kind != kind)
{
// should we eat the current ParseToken's leading trivia?
return(SyntaxFactory.MissingToken(kind));
}
else
{
return(this.EatToken());
}
}
public Cursor MoveToFirstToken()
{
var cursor = this;
if (!cursor.IsFinished)
{
for (var node = cursor.CurrentNodeOrToken; node.CSharpKind() != SyntaxKind.None && !SyntaxKindFacts.IsAnyToken(node.CSharpKind()); node = cursor.CurrentNodeOrToken)
{
cursor = cursor.MoveToFirstChild();
}
}
return(cursor);
}
