internal ResetPoint(int tokenIndex, LexerMode mode, bool greaterThanTokenIsNotOperator, TerminatorState termState)
{
TokenIndex = tokenIndex;
Mode = mode;
GreaterThanTokenIsNotOperator = greaterThanTokenIsNotOperator;
TermState = termState;
}
internal ResetPoint(
SyntaxParser.ResetPoint resetPoint,
TerminatorState terminatorState,
bool isInTry)
{
this.BaseResetPoint = resetPoint;
this.TerminatorState = terminatorState;
this.IsInTry = isInTry;
}
internal ResetPoint(
int tokenIndex, LexerMode mode,
bool greaterThanTokenIsNotOperator, bool allowLinearAndPointAsIdentifiers,
Stack <bool> commaIsSeparatorStack, TerminatorState termState)
{
TokenIndex = tokenIndex;
Mode = mode;
GreaterThanTokenIsNotOperator = greaterThanTokenIsNotOperator;
AllowLinearAndPointAsIdentifiers = allowLinearAndPointAsIdentifiers;
CommaIsSeparatorStack = new Stack <bool>(commaIsSeparatorStack.Reverse());
TermState = termState;
}
private TerminatorState _termState; // Resettable
private bool IsTerminator()
{
if (this.CurrentToken.Kind == SyntaxKind.EndOfFileToken)
{
return(true);
}
for (int i = 1; i <= LastTerminatorState; i <<= 1)
{
TerminatorState isolated = _termState & (TerminatorState)i;
if (isolated != 0)
{
switch (isolated)
{
case TerminatorState.IsPackageMemberStartOrStop:
if (this.IsPackageMemberStartOrStop())
{
return(true);
}
break;
case TerminatorState.IsAttributeDeclarationTerminator:
if (this.IsAttributeDeclarationTerminator())
{
return(true);
}
break;
case TerminatorState.IsPossibleAggregateClauseStartOrStop:
if (this.IsPossibleAggregateClauseStartOrStop())
{
return(true);
}
break;
case TerminatorState.IsPossibleMemberStartOrStop:
if (this.IsPossibleMemberStartOrStop())
{
return(true);
}
break;
case TerminatorState.IsEndOfReturnType:
if (this.IsEndOfReturnType())
{
return(true);
}
break;
case TerminatorState.IsEndOfParameterList:
if (this.IsEndOfParameterList())
{
return(true);
}
break;
case TerminatorState.IsEndOfFieldDeclaration:
if (this.IsEndOfFieldDeclaration())
{
return(true);
}
break;
case TerminatorState.IsPossibleEndOfVariableDeclaration:
if (this.IsPossibleEndOfVariableDeclaration())
{
return(true);
}
break;
case TerminatorState.IsEndOfTypeArgumentList:
if (this.IsEndOfTypeArgumentList())
{
return(true);
}
break;
case TerminatorState.IsPossibleStatementStartOrStop:
if (this.IsPossibleStatementStartOrStop())
{
return(true);
}
break;
case TerminatorState.IsEndOfTryBlock:
if (this.IsEndOfTryBlock())
{
return(true);
}
break;
case TerminatorState.IsEndOfCatchClause:
if (this.IsEndOfCatchClause())
{
return(true);
}
break;
case TerminatorState.IsEndOfilterClause:
if (this.IsEndOfFilterClause())
{
return(true);
}
break;
case TerminatorState.IsEndOfCatchBlock:
if (this.IsEndOfCatchBlock())
{
return(true);
}
break;
case TerminatorState.IsEndOfDoWhileExpression:
if (this.IsEndOfDoWhileExpression())
{
return(true);
}
break;
case TerminatorState.IsEndOfForStatementArgument:
if (this.IsEndOfForStatementArgument())
{
return(true);
}
break;
case TerminatorState.IsEndOfDeclarationClause:
if (this.IsEndOfDeclarationClause())
{
return(true);
}
break;
case TerminatorState.IsEndOfArgumentList:
if (this.IsEndOfArgumentList())
{
return(true);
}
break;
case TerminatorState.IsSwitchSectionStart:
if (this.IsPossibleSwitchSection())
{
return(true);
}
break;
case TerminatorState.IsEndOfTypeParameterList:
if (this.IsEndOfTypeParameterList())
{
return(true);
}
break;
case TerminatorState.IsEndOfMethodSignature:
if (this.IsEndOfMethodSignature())
{
return(true);
}
break;
case TerminatorState.IsEndOfNameInExplicitInterface:
if (this.IsEndOfNameInExplicitInterface())
{
return(true);
}
break;
}
}
}
return(false);
}
private VariableDeclaratorSyntax ParseVariableDeclarator(TypeSyntax parentType, VariableFlags flags, bool isFirst, bool isExpressionContext = false)
{
if (this.IsIncrementalAndFactoryContextMatches && CanReuseVariableDeclarator(this.CurrentNode as CSharp.Syntax.VariableDeclaratorSyntax, flags, isFirst))
{
return((VariableDeclaratorSyntax)this.EatNode());
}
if (!isExpressionContext)
{
// Check for the common pattern of:
//
// C //<-- here
// Console.WriteLine();
//
// Standard greedy parsing will assume that this should be parsed as a variable
// declaration: "C Console". We want to avoid that as it can confused parts of the
// system further up. So, if we see certain things following the identifier, then we can
// assume it's not the actual name.
//
// So, if we're after a newline and we see a name followed by the list below, then we
// assume that we're accidently consuming too far into the next statement.
//
// <dot>, <arrow>, any binary operator (except =), <question>. None of these characters
// are allowed in a normal variable declaration. This also provides a more useful error
// message to the user. Instead of telling them that a semicolon is expected after the
// following token, then instead get a useful message about an identifier being missing.
// The above list prevents:
//
// C //<-- here
// Console.WriteLine();
//
// C //<-- here
// Console->WriteLine();
//
// C
// A + B; // etc.
//
// C
// A ? B : D;
var resetPoint = this.GetResetPoint();
try
{
var currentTokenKind = this.CurrentToken.Kind;
if (currentTokenKind == SyntaxKind.IdentifierToken && !parentType.IsMissing)
{
var isAfterNewLine = parentType.GetLastToken().TrailingTrivia.Any(SyntaxKind.EndOfLineTrivia);
if (isAfterNewLine)
{
int offset, width;
this.GetDiagnosticSpanForMissingToken(out offset, out width);
this.EatToken();
currentTokenKind = this.CurrentToken.Kind;
var isNonEqualsBinaryToken =
currentTokenKind != SyntaxKind.EqualsToken &&
SyntaxKindFacts.IsBinaryExpressionOperatorToken(currentTokenKind);
if (currentTokenKind == SyntaxKind.DotToken ||
currentTokenKind == SyntaxKind.MinusGreaterThanToken ||
isNonEqualsBinaryToken)
{
var missingIdentifier = CreateMissingIdentifierToken();
missingIdentifier = this.AddError(missingIdentifier, offset, width, ErrorCode.ERR_IdentifierExpected);
return(_syntaxFactory.VariableDeclarator(missingIdentifier, default(SyntaxList <ArrayRankSpecifierSyntax>), null,
null));
}
}
}
}
finally
{
this.Reset(ref resetPoint);
this.Release(ref resetPoint);
}
}
//if (this.IsPossibleRankAndDimensionSpecifier())
//{
// var ranks = this._pool.Allocate<ArrayRankSpecifierSyntax>();
// try
// {
// while (this.IsPossibleRankAndDimensionSpecifier())
// {
// bool unused;
// var rank = this.ParseArrayRankSpecifier(isArrayCreation, expectSizes, out unused);
// ranks.Add(rank);
// expectSizes = false;
// }
// type = _syntaxFactory.ArrayType(type, ranks);
// }
// finally
// {
// this._pool.Free(ranks);
// }
//}
// NOTE: Diverges from Dev10.
//
// When we see parse an identifier and we see the partial contextual keyword, we check
// to see whether it is already attached to a partial class or partial method
// declaration. However, in the specific case of variable declarators, Dev10
// specifically treats it as a variable name, even if it could be interpreted as a
// keyword.
var name = this.ParseIdentifierToken();
BracketedArgumentListSyntax argumentList = null;
EqualsValueClauseSyntax initializer = null;
TerminatorState saveTerm = this._termState;
SyntaxList <ArrayRankSpecifierSyntax> ranges = default(SyntaxList <ArrayRankSpecifierSyntax>);
bool isLocal = (flags & VariableFlags.Local) != 0;
bool isFinal = (flags & VariableFlags.Final) != 0;
// Give better error message in the case where the user did something like:
//
// X x = 1, Y y = 2;
// using (X x = expr1, Y y = expr2) ...
//
// The superfluous type name is treated as variable (it is an identifier) and a missing ',' is injected after it.
if (!isFirst && this.IsTrueIdentifier())
{
name = this.AddError(name, ErrorCode.ERR_MultiTypeInDeclaration);
}
switch (this.CurrentToken.Kind)
{
case SyntaxKind.EqualsToken:
var equals = this.EatToken();
var init = this.ParseVariableInitializer(isLocal);
initializer = _syntaxFactory.EqualsValueClause(equals, init);
break;
case SyntaxKind.OpenParenToken:
// Special case for accidental use of C-style constructors
// Fake up something to hold the arguments.
this._termState |= TerminatorState.IsPossibleEndOfVariableDeclaration;
argumentList = this.ParseBracketedArgumentList();
this._termState = saveTerm;
argumentList = this.AddError(argumentList, ErrorCode.ERR_BadVarDecl);
break;
case SyntaxKind.OpenBracketToken:
bool sawNonOmittedSize;
if (this.IsPossibleRankAndDimensionSpecifier())
{
this._termState |= TerminatorState.IsPossibleEndOfVariableDeclaration;
var ranks = this._pool.Allocate <ArrayRankSpecifierSyntax>();
try
{
while (this.IsPossibleRankAndDimensionSpecifier())
{
var rank = this.ParseArrayRankSpecifier(false, false, out sawNonOmittedSize);
ranks.Add(rank);
}
}
finally
{
ranges = ranks.ToList();
this._pool.Free(ranks);
}
this._termState = saveTerm;
}
if (this.CurrentToken.Kind == SyntaxKind.EqualsToken)
{
goto case SyntaxKind.EqualsToken;
}
//this._termState |= TerminatorState.IsPossibleEndOfVariableDeclaration;
//var specifier = this.ParseArrayRankSpecifier(isArrayCreation: false, expectSizes: false, sawNonOmittedSize: out sawNonOmittedSize);
//this._termState = saveTerm;
//var open = specifier.OpenBracketToken;
//var sizes = specifier.Sizes;
//var close = specifier.CloseBracketToken;
//if (!sawNonOmittedSize)
//{
// close = this.AddError(close, ErrorCode.ERR_ValueExpected);
//}
//var args = this._pool.AllocateSeparated<ArgumentSyntax>();
//try
//{
// var withSeps = sizes.GetWithSeparators();
// foreach (var item in withSeps)
// {
// var expression = item as ExpressionSyntax;
// if (expression != null)
// {
// args.Add(_syntaxFactory.Argument(null, expression));
// }
// else
// {
// args.AddSeparator((SyntaxToken)item);
// }
// }
// argumentList = _syntaxFactory.BracketedArgumentList(open, args, close);
// {
// argumentList = this.AddError(argumentList, ErrorCode.ERR_CStyleArray);
// // If we have "int x[] = new int[10];" then parse the initializer.
// if (this.CurrentToken.Kind == SyntaxKind.EqualsToken)
// {
// goto case SyntaxKind.EqualsToken;
// }
// }
//}
//finally
//{
// this._pool.Free(args);
//}
break;
default:
//if (isFixed)
//{
// if (parentType.Kind == SyntaxKind.ArrayType)
// {
// // They accidentally put the array before the identifier
// name = this.AddError(name, ErrorCode.ERR_FixedDimsRequired);
// }
// else
// {
// goto case SyntaxKind.OpenBracketToken;
// }
//}
break;
}
return(_syntaxFactory.VariableDeclarator(name, ranges, argumentList, initializer));
}
private bool IsTerminator()
{
if (Current.Kind == SyntaxKind.EndOfFileToken)
{
return(true);
}
for (int i = 1; i <= LastTerminatorState; i <<= 1)
{
TerminatorState isolated = _termState & (TerminatorState)i;
if (isolated != 0)
{
switch (isolated)
{
case TerminatorState.IsPossibleGlobalDeclarationStartOrStop:
if (this.IsPossibleGlobalDeclarationStartOrStop())
{
return(true);
}
break;
//case TerminatorState.IsAttributeDeclarationTerminator:
// if (this.IsAttributeDeclarationTerminator())
// {
// return true;
// }
// break;
//case TerminatorState.IsPossibleMemberStartOrStop:
// if (this.IsPossibleMemberStartOrStop())
// {
// return true;
// }
// break;
//case TerminatorState.IsPossibleAggregateClauseStartOrStop:
// if (this.IsPossibleAggregateClauseStartOrStop())
// {
// return true;
// }
// break;
//case TerminatorState.IsEndOfReturnType:
// if (this.IsEndOfReturnType())
// {
// return true;
// }
// break;
//case TerminatorState.IsEndOfParameterList:
// if (this.IsEndOfParameterList())
// {
// return true;
// }
// break;
//case TerminatorState.IsEndOfFieldDeclaration:
// if (this.IsEndOfFieldDeclaration())
// {
// return true;
// }
// break;
//case TerminatorState.IsPossibleEndOfVariableDeclaration:
// if (this.IsPossibleEndOfVariableDeclaration())
// {
// return true;
// }
// break;
//case TerminatorState.IsEndOfTypeArgumentList:
// if (this.IsEndOfTypeArgumentList())
// {
// return true;
// }
// break;
case TerminatorState.IsPossibleStatementStartOrStop:
if (this.IsPossibleStatementStartOrStop())
{
return(true);
}
break;
//case TerminatorState.IsEndOfDoWhileExpression:
// if (this.IsEndOfDoWhileExpression())
// {
// return true;
// }
// break;
//case TerminatorState.IsEndOfForStatementArgument:
// if (this.IsEndOfForStatementArgument())
// {
// return true;
// }
// break;
//case TerminatorState.IsEndOfDeclarationClause:
// if (this.IsEndOfDeclarationClause())
// {
// return true;
// }
// break;
//case TerminatorState.IsEndOfArgumentList:
// if (this.IsEndOfArgumentList())
// {
// return true;
// }
// break;
//case TerminatorState.IsSwitchSectionStart:
// if (this.IsPossibleSwitchSection())
// {
// return true;
// }
// break;
//case TerminatorState.IsEndOfTypeParameterList:
// if (this.IsEndOfTypeParameterList())
// {
// return true;
// }
// break;
//case TerminatorState.IsEndOfMethodSignature:
// if (this.IsEndOfMethodSignature())
// {
// return true;
// }
// break;
}
}
}
return(false);
}
