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); }