2014-11-24 4:03 GMT+09:00 Daniel Jasper <[email protected]>: > Author: djasper > Date: Sun Nov 23 13:03:25 2014 > New Revision: 222638 > > URL: http://llvm.org/viewvc/llvm-project?rev=222638&view=rev > Log: > clang-format: Refactoring. > > Provide more overloads to simplify testing the type of a token. No > functional changes intended. > > Modified: > cfe/trunk/lib/Format/ContinuationIndenter.cpp > cfe/trunk/lib/Format/Format.cpp > cfe/trunk/lib/Format/FormatToken.h > cfe/trunk/lib/Format/TokenAnnotator.cpp > cfe/trunk/lib/Format/WhitespaceManager.cpp > > Modified: cfe/trunk/lib/Format/ContinuationIndenter.cpp > URL: > http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Format/ContinuationIndenter.cpp?rev=222638&r1=222637&r2=222638&view=diff > ============================================================================== > --- cfe/trunk/lib/Format/ContinuationIndenter.cpp (original) > +++ cfe/trunk/lib/Format/ContinuationIndenter.cpp Sun Nov 23 13:03:25 2014 > @@ -48,11 +48,11 @@ static bool startsSegmentOfBuilderTypeCa > static bool startsNextParameter(const FormatToken &Current, > const FormatStyle &Style) { > const FormatToken &Previous = *Current.Previous; > - if (Current.Type == TT_CtorInitializerComma && > + if (Current.is(TT_CtorInitializerComma) && > Style.BreakConstructorInitializersBeforeComma) > return true; > return Previous.is(tok::comma) && !Current.isTrailingComment() && > - (Previous.Type != TT_CtorInitializerComma || > + (Previous.isNot(TT_CtorInitializerComma) || > !Style.BreakConstructorInitializersBeforeComma); > } > > @@ -99,7 +99,7 @@ bool ContinuationIndenter::canBreak(cons > // The opening "{" of a braced list has to be on the same line as the first > // element if it is nested in another braced init list or function call. > if (!Current.MustBreakBefore && Previous.is(tok::l_brace) && > - Previous.Type != TT_DictLiteral && Previous.BlockKind == BK_BracedInit > && > + Previous.isNot(TT_DictLiteral) && Previous.BlockKind == BK_BracedInit > && > Previous.Previous && > Previous.Previous->isOneOf(tok::l_brace, tok::l_paren, tok::comma)) > return false; > @@ -124,7 +124,7 @@ bool ContinuationIndenter::canBreak(cons > > // Don't break after very short return types (e.g. "void") as that is often > // unexpected. > - if (Current.Type == TT_FunctionDeclarationName && > + if (Current.is(TT_FunctionDeclarationName) && > !Style.AlwaysBreakAfterDefinitionReturnType && State.Column < 6) > return false; > > @@ -134,7 +134,7 @@ bool ContinuationIndenter::canBreak(cons > bool ContinuationIndenter::mustBreak(const LineState &State) { > const FormatToken &Current = *State.NextToken; > const FormatToken &Previous = *Current.Previous; > - if (Current.MustBreakBefore || Current.Type == TT_InlineASMColon) > + if (Current.MustBreakBefore || Current.is(TT_InlineASMColon)) > return true; > if (State.Stack.back().BreakBeforeClosingBrace && > Current.closesBlockTypeList(Style)) > @@ -143,25 +143,25 @@ bool ContinuationIndenter::mustBreak(con > return true; > if ((startsNextParameter(Current, Style) || Previous.is(tok::semi) || > (Style.BreakBeforeTernaryOperators && > - (Current.is(tok::question) || (Current.Type == TT_ConditionalExpr && > - Previous.isNot(tok::question)))) || > + (Current.is(tok::question) || > + (Current.is(TT_ConditionalExpr) && Previous.isNot(tok::question)))) > || > (!Style.BreakBeforeTernaryOperators && > - (Previous.is(tok::question) || Previous.Type == > TT_ConditionalExpr))) && > + (Previous.is(tok::question) || Previous.is(TT_ConditionalExpr)))) && > State.Stack.back().BreakBeforeParameter && > !Current.isTrailingComment() && > !Current.isOneOf(tok::r_paren, tok::r_brace)) > return true; > if (Style.AlwaysBreakBeforeMultilineStrings && > State.Column > State.Stack.back().Indent && // Breaking saves columns. > !Previous.isOneOf(tok::kw_return, tok::lessless, tok::at) && > - Previous.Type != TT_InlineASMColon && > - Previous.Type != TT_ConditionalExpr && nextIsMultilineString(State)) > + !Previous.isOneOf(TT_InlineASMColon, TT_ConditionalExpr) && > + nextIsMultilineString(State)) > return true; > - if (((Previous.Type == TT_DictLiteral && Previous.is(tok::l_brace)) || > - Previous.Type == TT_ArrayInitializerLSquare) && > + if (((Previous.is(TT_DictLiteral) && Previous.is(tok::l_brace)) || > + Previous.is(TT_ArrayInitializerLSquare)) && > Style.ColumnLimit > 0 && > getLengthToMatchingParen(Previous) + State.Column > > getColumnLimit(State)) > return true; > - if (Current.Type == TT_CtorInitializerColon && > + if (Current.is(TT_CtorInitializerColon) && > ((Style.AllowShortFunctionsOnASingleLine != FormatStyle::SFS_All) || > Style.BreakConstructorInitializersBeforeComma || Style.ColumnLimit != > 0)) > return true; > @@ -184,12 +184,11 @@ bool ContinuationIndenter::mustBreak(con > bool IsComparison = (Previous.getPrecedence() == prec::Relational || > Previous.getPrecedence() == prec::Equality) && > Previous.Previous && > - Previous.Previous->Type != TT_BinaryOperator; // For > >>. > + Previous.Previous->isNot(TT_BinaryOperator); // For > >>. > bool LHSIsBinaryExpr = > Previous.Previous && Previous.Previous->EndsBinaryExpression; > - if (Previous.Type == TT_BinaryOperator && > - (!IsComparison || LHSIsBinaryExpr) && > - Current.Type != TT_BinaryOperator && // For >>. > + if (Previous.is(TT_BinaryOperator) && (!IsComparison || LHSIsBinaryExpr) > && > + Current.isNot(TT_BinaryOperator) && // For >>. > !Current.isTrailingComment() && !Previous.is(tok::lessless) && > Previous.getPrecedence() != prec::Assignment && > State.Stack.back().BreakBeforeParameter) > @@ -197,13 +196,12 @@ bool ContinuationIndenter::mustBreak(con > } > > // Same as above, but for the first "<<" operator. > - if (Current.is(tok::lessless) && Current.Type != TT_OverloadedOperator && > + if (Current.is(tok::lessless) && Current.isNot(TT_OverloadedOperator) && > State.Stack.back().BreakBeforeParameter && > State.Stack.back().FirstLessLess == 0) > return true; > > - if (Current.Type == TT_SelectorName && > - State.Stack.back().ObjCSelectorNameFound && > + if (Current.is(TT_SelectorName) && > State.Stack.back().ObjCSelectorNameFound && > State.Stack.back().BreakBeforeParameter) > return true; > if (Previous.ClosesTemplateDeclaration && Current.NestingLevel == 0 && > @@ -211,8 +209,7 @@ bool ContinuationIndenter::mustBreak(con > return true; > > // If the return type spans multiple lines, wrap before the function name. > - if ((Current.Type == TT_FunctionDeclarationName || > - Current.is(tok::kw_operator)) && > + if (Current.isOneOf(TT_FunctionDeclarationName ,tok::kw_operator) && > State.Stack.back().BreakBeforeParameter) > return true; > > @@ -238,7 +235,7 @@ unsigned ContinuationIndenter::addTokenT > const FormatToken &Current = *State.NextToken; > > assert(!State.Stack.empty()); > - if ((Current.Type == TT_ImplicitStringLiteral && > + if ((Current.is(TT_ImplicitStringLiteral) && > (Current.Previous->Tok.getIdentifierInfo() == nullptr || > Current.Previous->Tok.getIdentifierInfo()->getPPKeywordID() == > tok::pp_not_keyword))) { > @@ -287,7 +284,7 @@ void ContinuationIndenter::addTokenOnCur > Whitespaces.replaceWhitespace(Current, /*Newlines=*/0, /*IndentLevel=*/0, > Spaces, State.Column + Spaces); > > - if (Current.Type == TT_SelectorName && > + if (Current.is(TT_SelectorName) && > !State.Stack.back().ObjCSelectorNameFound) { > if (Current.LongestObjCSelectorName == 0) > State.Stack.back().AlignColons = false; > @@ -299,9 +296,9 @@ void ContinuationIndenter::addTokenOnCur > State.Stack.back().ColonPos = State.Column + Spaces + > Current.ColumnWidth; > } > > - if (Style.AlignAfterOpenBracket && > - Previous.opensScope() && Previous.Type != TT_ObjCMethodExpr && > - (Current.Type != TT_LineComment || Previous.BlockKind == > BK_BracedInit)) > + if (Style.AlignAfterOpenBracket && Previous.opensScope() && > + Previous.isNot(TT_ObjCMethodExpr) && > + (Current.isNot(TT_LineComment) || Previous.BlockKind == BK_BracedInit)) > State.Stack.back().Indent = State.Column + Spaces; > if (State.Stack.back().AvoidBinPacking && startsNextParameter(Current, > Style)) > State.Stack.back().NoLineBreak = true; > @@ -328,11 +325,10 @@ void ContinuationIndenter::addTokenOnCur > State.Stack.back().LastSpace = State.Column; > else if (!Current.isOneOf(tok::comment, tok::caret) && > (Previous.is(tok::comma) || > - (Previous.is(tok::colon) && Previous.Type == TT_ObjCMethodExpr))) > + (Previous.is(tok::colon) && Previous.is(TT_ObjCMethodExpr)))) > State.Stack.back().LastSpace = State.Column; > - else if ((Previous.Type == TT_BinaryOperator || > - Previous.Type == TT_ConditionalExpr || > - Previous.Type == TT_CtorInitializerColon) && > + else if ((Previous.isOneOf(TT_BinaryOperator, TT_ConditionalExpr, > + TT_CtorInitializerColon)) && > ((Previous.getPrecedence() != prec::Assignment && > (Previous.isNot(tok::lessless) || Previous.OperatorIndex != 0 || > !Previous.LastOperator)) || > @@ -341,7 +337,7 @@ void ContinuationIndenter::addTokenOnCur > // simple assignment without binary expression on the RHS. Also indent > // relative to unary operators and the colons of constructor > initializers. > State.Stack.back().LastSpace = State.Column; > - else if (Previous.Type == TT_InheritanceColon) { > + else if (Previous.is(TT_InheritanceColon)) { > State.Stack.back().Indent = State.Column; > State.Stack.back().LastSpace = State.Column; > } else if (Previous.opensScope()) { > @@ -395,7 +391,7 @@ unsigned ContinuationIndenter::addTokenO > if (NextNonComment->isMemberAccess()) { > if (State.Stack.back().CallContinuation == 0) > State.Stack.back().CallContinuation = State.Column; > - } else if (NextNonComment->Type == TT_SelectorName) { > + } else if (NextNonComment->is(TT_SelectorName)) { > if (!State.Stack.back().ObjCSelectorNameFound) { > if (NextNonComment->LongestObjCSelectorName == 0) { > State.Stack.back().AlignColons = false; > @@ -408,8 +404,7 @@ unsigned ContinuationIndenter::addTokenO > State.Stack.back().ColonPos = State.Column + > NextNonComment->ColumnWidth; > } > } else if (PreviousNonComment && PreviousNonComment->is(tok::colon) && > - (PreviousNonComment->Type == TT_ObjCMethodExpr || > - PreviousNonComment->Type == TT_DictLiteral)) { > + PreviousNonComment->isOneOf(TT_ObjCMethodExpr, TT_DictLiteral)) > { > // FIXME: This is hacky, find a better way. The problem is that in an > ObjC > // method expression, the block should be aligned to the line starting > it, > // e.g.: > @@ -427,10 +422,9 @@ unsigned ContinuationIndenter::addTokenO > > if ((Previous.isOneOf(tok::comma, tok::semi) && > !State.Stack.back().AvoidBinPacking) || > - Previous.Type == TT_BinaryOperator) > + Previous.is(TT_BinaryOperator)) > State.Stack.back().BreakBeforeParameter = false; > - if ((Previous.Type == TT_TemplateCloser || > - Previous.Type == TT_JavaAnnotation) && > + if (Previous.isOneOf(TT_TemplateCloser, TT_JavaAnnotation) && > Current.NestingLevel == 0) > State.Stack.back().BreakBeforeParameter = false; > if (NextNonComment->is(tok::question) || > @@ -463,30 +457,27 @@ unsigned ContinuationIndenter::addTokenO > > if (PreviousNonComment && > !PreviousNonComment->isOneOf(tok::comma, tok::semi) && > - (PreviousNonComment->Type != TT_TemplateCloser || > + (PreviousNonComment->isNot(TT_TemplateCloser) || > Current.NestingLevel != 0) && > - PreviousNonComment->Type != TT_BinaryOperator && > - PreviousNonComment->Type != TT_JavaAnnotation && > - PreviousNonComment->Type != TT_LeadingJavaAnnotation && > - Current.Type != TT_BinaryOperator && !PreviousNonComment->opensScope()) > + !PreviousNonComment->isOneOf(TT_BinaryOperator, TT_JavaAnnotation, > + TT_LeadingJavaAnnotation) && > + Current.isNot(TT_BinaryOperator) && !PreviousNonComment->opensScope()) > State.Stack.back().BreakBeforeParameter = true; > > // If we break after { or the [ of an array initializer, we should also > break > // before the corresponding } or ]. > if (PreviousNonComment && > - (PreviousNonComment->is(tok::l_brace) || > - PreviousNonComment->Type == TT_ArrayInitializerLSquare)) > + (PreviousNonComment->isOneOf(tok::l_brace, > TT_ArrayInitializerLSquare))) > State.Stack.back().BreakBeforeClosingBrace = true; > > if (State.Stack.back().AvoidBinPacking) { > // If we are breaking after '(', '{', '<', this is not bin packing > // unless AllowAllParametersOfDeclarationOnNextLine is false or this is a > // dict/object literal. > - if (!(Previous.isOneOf(tok::l_paren, tok::l_brace) || > - Previous.Type == TT_BinaryOperator) || > + if (!Previous.isOneOf(tok::l_paren, tok::l_brace, TT_BinaryOperator) || > (!Style.AllowAllParametersOfDeclarationOnNextLine && > State.Line->MustBeDeclaration) || > - Previous.Type == TT_DictLiteral) > + Previous.is(TT_DictLiteral)) > State.Stack.back().BreakBeforeParameter = true; > } > > @@ -528,7 +519,7 @@ unsigned ContinuationIndenter::getNewLin > return State.FirstIndent; > } > if (Current.is(tok::identifier) && Current.Next && > - Current.Next->Type == TT_DictLiteral) > + Current.Next->is(TT_DictLiteral)) > return State.Stack.back().Indent; > if (NextNonComment->isStringLiteral() && State.StartOfStringLiteral != 0) > return State.StartOfStringLiteral; > @@ -544,21 +535,19 @@ unsigned ContinuationIndenter::getNewLin > } > if (State.Stack.back().QuestionColumn != 0 && > ((NextNonComment->is(tok::colon) && > - NextNonComment->Type == TT_ConditionalExpr) || > - Previous.Type == TT_ConditionalExpr)) > + NextNonComment->is(TT_ConditionalExpr)) || > + Previous.is(TT_ConditionalExpr))) > return State.Stack.back().QuestionColumn; > if (Previous.is(tok::comma) && State.Stack.back().VariablePos != 0) > return State.Stack.back().VariablePos; > if ((PreviousNonComment && > (PreviousNonComment->ClosesTemplateDeclaration || > - PreviousNonComment->Type == TT_AttributeParen || > - PreviousNonComment->Type == TT_JavaAnnotation || > - PreviousNonComment->Type == TT_LeadingJavaAnnotation)) || > + PreviousNonComment->isOneOf(TT_AttributeParen, TT_JavaAnnotation, > + TT_LeadingJavaAnnotation))) || > (!Style.IndentWrappedFunctionNames && > - (NextNonComment->is(tok::kw_operator) || > - NextNonComment->Type == TT_FunctionDeclarationName))) > + NextNonComment->isOneOf(tok::kw_operator, > TT_FunctionDeclarationName))) > return std::max(State.Stack.back().LastSpace, State.Stack.back().Indent); > - if (NextNonComment->Type == TT_SelectorName) { > + if (NextNonComment->is(TT_SelectorName)) { > if (!State.Stack.back().ObjCSelectorNameFound) { > if (NextNonComment->LongestObjCSelectorName == 0) { > return State.Stack.back().Indent; > @@ -575,23 +564,22 @@ unsigned ContinuationIndenter::getNewLin > return State.Stack.back().Indent; > } > } > - if (NextNonComment->Type == TT_ArraySubscriptLSquare) { > + if (NextNonComment->is(TT_ArraySubscriptLSquare)) { > if (State.Stack.back().StartOfArraySubscripts != 0) > return State.Stack.back().StartOfArraySubscripts; > else > return ContinuationIndent; > } > - if (NextNonComment->Type == TT_StartOfName || > + if (NextNonComment->is(TT_StartOfName) || > Previous.isOneOf(tok::coloncolon, tok::equal)) { > return ContinuationIndent; > } > if (PreviousNonComment && PreviousNonComment->is(tok::colon) && > - (PreviousNonComment->Type == TT_ObjCMethodExpr || > - PreviousNonComment->Type == TT_DictLiteral)) > + PreviousNonComment->isOneOf(TT_ObjCMethodExpr, TT_DictLiteral)) > return ContinuationIndent; > - if (NextNonComment->Type == TT_CtorInitializerColon) > + if (NextNonComment->is(TT_CtorInitializerColon)) > return State.FirstIndent + Style.ConstructorInitializerIndentWidth; > - if (NextNonComment->Type == TT_CtorInitializerComma) > + if (NextNonComment->is(TT_CtorInitializerComma)) > return State.Stack.back().Indent; > if (Previous.is(tok::r_paren) && !Current.isBinaryOperator() && > !Current.isOneOf(tok::colon, tok::comment)) > @@ -609,18 +597,18 @@ unsigned ContinuationIndenter::moveState > assert(State.Stack.size()); > const FormatToken &Current = *State.NextToken; > > - if (Current.Type == TT_InheritanceColon) > + if (Current.is(TT_InheritanceColon)) > State.Stack.back().AvoidBinPacking = true; > - if (Current.is(tok::lessless) && Current.Type != TT_OverloadedOperator) { > + if (Current.is(tok::lessless) && Current.isNot(TT_OverloadedOperator)) { > if (State.Stack.back().FirstLessLess == 0) > State.Stack.back().FirstLessLess = State.Column; > else > State.Stack.back().LastOperatorWrapped = Newline; > } > - if ((Current.Type == TT_BinaryOperator && Current.isNot(tok::lessless)) || > - Current.Type == TT_ConditionalExpr) > + if ((Current.is(TT_BinaryOperator) && Current.isNot(tok::lessless)) || > + Current.is(TT_ConditionalExpr)) > State.Stack.back().LastOperatorWrapped = Newline; > - if (Current.Type == TT_ArraySubscriptLSquare && > + if (Current.is(TT_ArraySubscriptLSquare) && > State.Stack.back().StartOfArraySubscripts == 0) > State.Stack.back().StartOfArraySubscripts = State.Column; > if ((Current.is(tok::question) && Style.BreakBeforeTernaryOperators) || > @@ -634,9 +622,9 @@ unsigned ContinuationIndenter::moveState > if (Current.isMemberAccess()) > State.Stack.back().StartOfFunctionCall = > Current.LastOperator ? 0 : State.Column + Current.ColumnWidth; > - if (Current.Type == TT_SelectorName) > + if (Current.is(TT_SelectorName)) > State.Stack.back().ObjCSelectorNameFound = true; > - if (Current.Type == TT_CtorInitializerColon) { > + if (Current.is(TT_CtorInitializerColon)) { > // Indent 2 from the column, so: > // SomeClass::SomeClass() > // : First(...), ... > @@ -652,7 +640,7 @@ unsigned ContinuationIndenter::moveState > // In ObjC method declaration we align on the ":" of parameters, but we > need > // to ensure that we indent parameters on subsequent lines by at least our > // continuation indent width. > - if (Current.Type == TT_ObjCMethodSpecifier) > + if (Current.is(TT_ObjCMethodSpecifier)) > State.Stack.back().Indent += Style.ContinuationIndentWidth; > > // Insert scopes created by fake parenthesis. > @@ -725,7 +713,7 @@ void ContinuationIndenter::moveStatePast > bool SkipFirstExtraIndent = > (Previous && (Previous->opensScope() || Previous->is(tok::kw_return) || > Previous->getPrecedence() == prec::Assignment || > - Previous->Type == TT_ObjCMethodExpr)); > + Previous->is(TT_ObjCMethodExpr))); > for (SmallVectorImpl<prec::Level>::const_reverse_iterator > I = Current.FakeLParens.rbegin(), > E = Current.FakeLParens.rend(); > @@ -750,13 +738,12 @@ void ContinuationIndenter::moveStatePast > // Exclude relational operators, as there, it is always more desirable to > // have the LHS 'left' of the RHS. > if (Previous && Previous->getPrecedence() > prec::Assignment && > - (Previous->Type == TT_BinaryOperator || > - Previous->Type == TT_ConditionalExpr) && > + Previous->isOneOf(TT_BinaryOperator, TT_ConditionalExpr) && > Previous->getPrecedence() != prec::Relational) { > bool BreakBeforeOperator = Previous->is(tok::lessless) || > - (Previous->Type == TT_BinaryOperator && > + (Previous->is(TT_BinaryOperator) && > Style.BreakBeforeBinaryOperators) || > - (Previous->Type == TT_ConditionalExpr && > + (Previous->is(TT_ConditionalExpr) && > Style.BreakBeforeTernaryOperators); > if ((!Newline && !BreakBeforeOperator) || > (!State.Stack.back().LastOperatorWrapped && BreakBeforeOperator)) > @@ -829,8 +816,7 @@ static bool fakeRParenSpecialCase(const > return !State.Stack.back().HasMultipleNestedBlocks && > Left->isOneOf(tok::l_brace, tok::l_square) && > (Left->BlockKind == BK_Block || > - Left->Type == TT_ArrayInitializerLSquare || > - Left->Type == TT_DictLiteral); > + Left->isOneOf(TT_ArrayInitializerLSquare, TT_DictLiteral)); > } > > void ContinuationIndenter::moveStatePastFakeRParens(LineState &State) { > @@ -857,7 +843,7 @@ void ContinuationIndenter::moveStatePast > unsigned NewIndentLevel = State.Stack.back().IndentLevel; > bool AvoidBinPacking; > bool BreakBeforeParameter = false; > - if (Current.is(tok::l_brace) || Current.Type == > TT_ArrayInitializerLSquare) { > + if (Current.isOneOf(tok::l_brace, TT_ArrayInitializerLSquare)) { > if (fakeRParenSpecialCase(State)) > consumeRParens(State, *Current.MatchingParen); > > @@ -871,12 +857,10 @@ void ContinuationIndenter::moveStatePast > NewIndent = std::min(State.Column + 1, NewIndent); > } > const FormatToken *NextNoComment = Current.getNextNonComment(); > - AvoidBinPacking = Current.Type == TT_ArrayInitializerLSquare || > - Current.Type == TT_DictLiteral || > - Style.Language == FormatStyle::LK_Proto || > - !Style.BinPackParameters || > - (NextNoComment && > - NextNoComment->Type == > TT_DesignatedInitializerPeriod); > + AvoidBinPacking = > + Current.isOneOf(TT_ArrayInitializerLSquare, TT_DictLiteral) || > + Style.Language == FormatStyle::LK_Proto || !Style.BinPackParameters > || > + (NextNoComment && NextNoComment->is(TT_DesignatedInitializerPeriod)); > } else { > NewIndent = Style.ContinuationIndentWidth + > std::max(State.Stack.back().LastSpace, > @@ -890,13 +874,13 @@ void ContinuationIndenter::moveStatePast > Current.PackingKind == PPK_Inconclusive))); > // If this '[' opens an ObjC call, determine whether all parameters fit > // into one line and put one per line if they don't. > - if (Current.Type == TT_ObjCMethodExpr && Style.ColumnLimit != 0 && > + if (Current.is(TT_ObjCMethodExpr) && Style.ColumnLimit != 0 && > getLengthToMatchingParen(Current) + State.Column > > getColumnLimit(State)) > BreakBeforeParameter = true; > } > bool NoLineBreak = State.Stack.back().NoLineBreak || > - (Current.Type == TT_TemplateOpener && > + (Current.is(TT_TemplateOpener) && > State.Stack.back().ContainsUnwrappedBuilder); > State.Stack.push_back(ParenState(NewIndent, NewIndentLevel, > State.Stack.back().LastSpace, > @@ -915,7 +899,7 @@ void ContinuationIndenter::moveStatePast > if (State.Stack.size() > 1 && > (Current.isOneOf(tok::r_paren, tok::r_square) || > (Current.is(tok::r_brace) && State.NextToken != State.Line->First) || > - State.NextToken->Type == TT_TemplateCloser)) > + State.NextToken->is(TT_TemplateCloser))) > State.Stack.pop_back(); > > if (Current.is(tok::r_square)) { > @@ -933,10 +917,10 @@ void ContinuationIndenter::moveStateToNe > consumeRParens(State, *State.NextToken->MatchingParen); > > // ObjC block sometimes follow special indentation rules. > - unsigned NewIndent = State.Stack.back().LastSpace + > - (State.NextToken->Type == TT_ObjCBlockLBrace > - ? Style.ObjCBlockIndentWidth > - : Style.IndentWidth); > + unsigned NewIndent = > + State.Stack.back().LastSpace + (State.NextToken->is(TT_ObjCBlockLBrace) > + ? Style.ObjCBlockIndentWidth > + : Style.IndentWidth); > State.Stack.push_back(ParenState( > NewIndent, /*NewIndentLevel=*/State.Stack.back().IndentLevel + 1, > State.Stack.back().LastSpace, /*AvoidBinPacking=*/true, > @@ -983,11 +967,11 @@ unsigned ContinuationIndenter::breakProt > bool DryRun) { > // Don't break multi-line tokens other than block comments. Instead, just > // update the state. > - if (Current.Type != TT_BlockComment && Current.IsMultiline) > + if (Current.isNot(TT_BlockComment) && Current.IsMultiline) > return addMultilineToken(Current, State); > > // Don't break implicit string literals or import statements. > - if (Current.Type == TT_ImplicitStringLiteral || > + if (Current.is(TT_ImplicitStringLiteral) || > State.Line->Type == LT_ImportStatement) > return 0; > > @@ -1037,15 +1021,15 @@ unsigned ContinuationIndenter::breakProt > } else { > return 0; > } > - } else if (Current.Type == TT_BlockComment && Current.isTrailingComment()) > { > + } else if (Current.is(TT_BlockComment) && Current.isTrailingComment()) { > if (CommentPragmasRegex.match(Current.TokenText.substr(2))) > return 0; > Token.reset(new BreakableBlockComment( > Current, State.Line->Level, StartColumn, Current.OriginalColumn, > !Current.Previous, State.Line->InPPDirective, Encoding, Style)); > - } else if (Current.Type == TT_LineComment && > + } else if (Current.is(TT_LineComment) && > (Current.Previous == nullptr || > - Current.Previous->Type != TT_ImplicitStringLiteral)) { > + Current.Previous->isNot(TT_ImplicitStringLiteral))) { > if (CommentPragmasRegex.match(Current.TokenText.substr(2))) > return 0; > Token.reset(new BreakableLineComment(Current, State.Line->Level, > @@ -1119,7 +1103,7 @@ unsigned ContinuationIndenter::breakProt > // If we break the token inside a parameter list, we need to break before > // the next parameter on all levels, so that the next parameter is > clearly > // visible. Line comments already introduce a break. > - if (Current.Type != TT_LineComment) { > + if (Current.isNot(TT_LineComment)) { > for (unsigned i = 0, e = State.Stack.size(); i != e; ++i) > State.Stack[i].BreakBeforeParameter = true; > } > @@ -1139,7 +1123,7 @@ unsigned ContinuationIndenter::getColumn > > bool ContinuationIndenter::nextIsMultilineString(const LineState &State) { > const FormatToken &Current = *State.NextToken; > - if (!Current.isStringLiteral() || Current.Type == TT_ImplicitStringLiteral) > + if (!Current.isStringLiteral() || Current.is(TT_ImplicitStringLiteral)) > return false; > // We never consider raw string literals "multiline" for the purpose of > // AlwaysBreakBeforeMultilineStrings implementation as they are > special-cased > > Modified: cfe/trunk/lib/Format/Format.cpp > URL: > http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Format/Format.cpp?rev=222638&r1=222637&r2=222638&view=diff > ============================================================================== > --- cfe/trunk/lib/Format/Format.cpp (original) > +++ cfe/trunk/lib/Format/Format.cpp Sun Nov 23 13:03:25 2014 > @@ -618,7 +618,7 @@ public: > SmallVectorImpl<AnnotatedLine *>::const_iterator > E) { > // We can never merge stuff if there are trailing line comments. > const AnnotatedLine *TheLine = *I; > - if (TheLine->Last->Type == TT_LineComment) > + if (TheLine->Last->is(TT_LineComment)) > return 0; > > if (Style.ColumnLimit > 0 && Indent > Style.ColumnLimit) > @@ -642,7 +642,7 @@ public: > (Style.AllowShortFunctionsOnASingleLine == FormatStyle::SFS_Inline && > TheLine->Level != 0); > > - if (TheLine->Last->Type == TT_FunctionLBrace && > + if (TheLine->Last->is(TT_FunctionLBrace) && > TheLine->First != TheLine->Last) { > return MergeShortFunctions ? tryMergeSimpleBlock(I, E, Limit) : 0; > } > @@ -651,7 +651,7 @@ public: > ? tryMergeSimpleBlock(I, E, Limit) > : 0; > } > - if (I[1]->First->Type == TT_FunctionLBrace && > + if (I[1]->First->is(TT_FunctionLBrace) && > Style.BreakBeforeBraces != FormatStyle::BS_Attach) { > // Check for Limit <= 2 to account for the " {". > if (Limit <= 2 || (Style.ColumnLimit == 0 && > containsMustBreak(TheLine))) > @@ -725,8 +725,7 @@ private: > if (1 + I[1]->Last->TotalLength > Limit) > return 0; > if (I[1]->First->isOneOf(tok::semi, tok::kw_if, tok::kw_for, > - tok::kw_while) || > - I[1]->First->Type == TT_LineComment) > + tok::kw_while, TT_LineComment)) > return 0; > // Only inline simple if's (no nested if or else). > if (I + 2 != E && Line.First->is(tok::kw_if) && > @@ -813,7 +812,7 @@ private: > > // Second, check that the next line does not contain any braces - if it > // does, readability declines when putting it into a single line. > - if (I[1]->Last->Type == TT_LineComment) > + if (I[1]->Last->is(TT_LineComment)) > return 0; > do { > if (Tok->is(tok::l_brace) && Tok->BlockKind != BK_BracedInit) > @@ -1655,7 +1654,7 @@ private: > } > } > > - if (FormatTok->Type == TT_ImplicitStringLiteral) > + if (FormatTok->is(TT_ImplicitStringLiteral)) > break; > WhitespaceLength += FormatTok->Tok.getLength(); > > @@ -2027,7 +2026,7 @@ private: > continue; > FormatToken *Tok = AnnotatedLines[i]->First->Next; > while (Tok->Next) { > - if (Tok->Type == TT_PointerOrReference) { > + if (Tok->is(TT_PointerOrReference)) { > bool SpacesBefore = > Tok->WhitespaceRange.getBegin() != > Tok->WhitespaceRange.getEnd(); > bool SpacesAfter = Tok->Next->WhitespaceRange.getBegin() != > @@ -2039,11 +2038,10 @@ private: > } > > if (Tok->WhitespaceRange.getBegin() == > Tok->WhitespaceRange.getEnd()) { > - if (Tok->is(tok::coloncolon) && > - Tok->Previous->Type == TT_TemplateOpener) > + if (Tok->is(tok::coloncolon) && > Tok->Previous->is(TT_TemplateOpener)) > HasCpp03IncompatibleFormat = true; > - if (Tok->Type == TT_TemplateCloser && > - Tok->Previous->Type == TT_TemplateCloser) > + if (Tok->is(TT_TemplateCloser) && > + Tok->Previous->is(TT_TemplateCloser)) > HasCpp03IncompatibleFormat = true; > } > > > Modified: cfe/trunk/lib/Format/FormatToken.h > URL: > http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Format/FormatToken.h?rev=222638&r1=222637&r2=222638&view=diff > ============================================================================== > --- cfe/trunk/lib/Format/FormatToken.h (original) > +++ cfe/trunk/lib/Format/FormatToken.h Sun Nov 23 13:03:25 2014 > @@ -271,38 +271,22 @@ struct FormatToken { > bool IsForEachMacro; > > bool is(tok::TokenKind Kind) const { return Tok.is(Kind); } > - > bool is(TokenType TT) const { return Type == TT; } > - > bool is(const IdentifierInfo *II) const { > return II && II == Tok.getIdentifierInfo(); > } > > - template <typename T> > - bool isOneOf(T K1, T K2) const { > + bool isOneOf() const { return false; } > + template <typename T, typename... L> bool isOneOf(T Type, L... args) const > { > + return is(Type) || isOneOf(args...); > + }
Variadic templates are unsupported in Visual Studio 2012. http://bb.pgr.jp/builders/ninja-clang-i686-msc17-R/builds/11709 > + // This overload increases performance by ~3%. > + // FIXME: Re-evaluate this. > + template <typename T> bool isOneOf(T K1, T K2) const { > return is(K1) || is(K2); > } > > - template <typename T> > - bool isOneOf(T K1, T K2, T K3) const { > - return is(K1) || is(K2) || is(K3); > - } > - > - template <typename T> > - bool isOneOf(T K1, T K2, T K3, T K4, T K5 = tok::NUM_TOKENS, > - T K6 = tok::NUM_TOKENS, T K7 = tok::NUM_TOKENS, > - T K8 = tok::NUM_TOKENS, T K9 = tok::NUM_TOKENS, > - T K10 = tok::NUM_TOKENS, T K11 = tok::NUM_TOKENS, > - T K12 = tok::NUM_TOKENS) const { > - return is(K1) || is(K2) || is(K3) || is(K4) || is(K5) || is(K6) || > is(K7) || > - is(K8) || is(K9) || is(K10) || is(K11) || is(K12); > - } > - > - template <typename T> > - bool isNot(T Kind) const { > - return Tok.isNot(Kind); > - } > - bool isNot(IdentifierInfo *II) const { return II != > Tok.getIdentifierInfo(); } > + template <typename T> bool isNot(T Kind) const { return !is(Kind); } > > bool isStringLiteral() const { return tok::isStringLiteral(Tok.getKind()); > } > > @@ -327,20 +311,19 @@ struct FormatToken { > > /// \brief Returns whether \p Tok is ([{ or a template opening <. > bool opensScope() const { > - return isOneOf(tok::l_paren, tok::l_brace, tok::l_square) || > - Type == TT_TemplateOpener; > + return isOneOf(tok::l_paren, tok::l_brace, tok::l_square, > + TT_TemplateOpener); > } > /// \brief Returns whether \p Tok is )]} or a template closing >. > bool closesScope() const { > - return isOneOf(tok::r_paren, tok::r_brace, tok::r_square) || > - Type == TT_TemplateCloser; > + return isOneOf(tok::r_paren, tok::r_brace, tok::r_square, > + TT_TemplateCloser); > } > > /// \brief Returns \c true if this is a "." or "->" accessing a member. > bool isMemberAccess() const { > return isOneOf(tok::arrow, tok::period, tok::arrowstar) && > - Type != TT_DesignatedInitializerPeriod && > - Type != TT_TrailingReturnArrow; > + !isOneOf(TT_DesignatedInitializerPeriod, TT_TrailingReturnArrow); > } > > bool isUnaryOperator() const { > @@ -366,7 +349,7 @@ struct FormatToken { > > bool isTrailingComment() const { > return is(tok::comment) && > - (Type == TT_LineComment || !Next || Next->NewlinesBefore > 0); > + (is(TT_LineComment) || !Next || Next->NewlinesBefore > 0); > } > > /// \brief Returns \c true if this is a keyword that can be used > @@ -412,10 +395,9 @@ struct FormatToken { > /// \brief Returns \c true if this tokens starts a block-type list, i.e. a > /// list that should be indented with a block indent. > bool opensBlockTypeList(const FormatStyle &Style) const { > - return Type == TT_ArrayInitializerLSquare || > - (is(tok::l_brace) && > - (BlockKind == BK_Block || Type == TT_DictLiteral || > - !Style.Cpp11BracedListStyle)); > + return is(TT_ArrayInitializerLSquare) || > + (is(tok::l_brace) && (BlockKind == BK_Block || is(TT_DictLiteral) > || > + !Style.Cpp11BracedListStyle)); > } > > /// \brief Same as opensBlockTypeList, but for the closing token. > > Modified: cfe/trunk/lib/Format/TokenAnnotator.cpp > URL: > http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Format/TokenAnnotator.cpp?rev=222638&r1=222637&r2=222638&view=diff > ============================================================================== > --- cfe/trunk/lib/Format/TokenAnnotator.cpp (original) > +++ cfe/trunk/lib/Format/TokenAnnotator.cpp Sun Nov 23 13:03:25 2014 > @@ -78,7 +78,7 @@ private: > // parameters. > // FIXME: This is getting out of hand, write a decent parser. > if (CurrentToken->Previous->isOneOf(tok::pipepipe, tok::ampamp) && > - CurrentToken->Previous->Type == TT_BinaryOperator && > + CurrentToken->Previous->is(TT_BinaryOperator) && > Contexts[Contexts.size() - 2].IsExpression && > Line.First->isNot(tok::kw_template)) > return false; > @@ -114,17 +114,17 @@ private: > if (Left->Previous && > (Left->Previous->isOneOf(tok::kw_static_assert, tok::kw_if, > tok::kw_while, tok::l_paren, tok::comma) || > - Left->Previous->Type == TT_BinaryOperator)) { > + Left->Previous->is(TT_BinaryOperator))) { > // static_assert, if and while usually contain expressions. > Contexts.back().IsExpression = true; > } else if (Line.InPPDirective && > (!Left->Previous || > - (Left->Previous->isNot(tok::identifier) && > - Left->Previous->Type != TT_OverloadedOperator))) { > + !Left->Previous->isOneOf(tok::identifier, > + TT_OverloadedOperator))) { > Contexts.back().IsExpression = true; > } else if (Left->Previous && Left->Previous->is(tok::r_square) && > Left->Previous->MatchingParen && > - Left->Previous->MatchingParen->Type == TT_LambdaLSquare) { > + Left->Previous->MatchingParen->is(TT_LambdaLSquare)) { > // This is a parameter list of a lambda expression. > Contexts.back().IsExpression = false; > } else if (Contexts[Contexts.size() - 2].CaretFound) { > @@ -137,7 +137,7 @@ private: > Contexts.back().IsForEachMacro = true; > Contexts.back().IsExpression = false; > } else if (Left->Previous && Left->Previous->MatchingParen && > - Left->Previous->MatchingParen->Type == TT_ObjCBlockLParen) { > + Left->Previous->MatchingParen->is(TT_ObjCBlockLParen)) { > Contexts.back().IsExpression = false; > } > > @@ -168,11 +168,11 @@ private: > } > } > > - if (CurrentToken->Previous->Type == TT_PointerOrReference && > + if (CurrentToken->Previous->is(TT_PointerOrReference) && > CurrentToken->Previous->Previous->isOneOf(tok::l_paren, > tok::coloncolon)) > MightBeFunctionType = true; > - if (CurrentToken->Previous->Type == TT_BinaryOperator) > + if (CurrentToken->Previous->is(TT_BinaryOperator)) > Contexts.back().IsExpression = true; > if (CurrentToken->is(tok::r_paren)) { > if (MightBeFunctionType && CurrentToken->Next && > @@ -191,11 +191,11 @@ private: > } > } > > - if (Left->Type == TT_AttributeParen) > + if (Left->is(TT_AttributeParen)) > CurrentToken->Type = TT_AttributeParen; > - if (Left->Previous && Left->Previous->Type == TT_JavaAnnotation) > + if (Left->Previous && Left->Previous->is(TT_JavaAnnotation)) > CurrentToken->Type = TT_JavaAnnotation; > - if (Left->Previous && Left->Previous->Type == > TT_LeadingJavaAnnotation) > + if (Left->Previous && Left->Previous->is(TT_LeadingJavaAnnotation)) > CurrentToken->Type = TT_LeadingJavaAnnotation; > > if (!HasMultipleLines) > @@ -239,12 +239,13 @@ private: > FormatToken *Left = CurrentToken->Previous; > FormatToken *Parent = Left->getPreviousNonComment(); > bool StartsObjCMethodExpr = > - Contexts.back().CanBeExpression && Left->Type != TT_LambdaLSquare && > + Contexts.back().CanBeExpression && Left->isNot(TT_LambdaLSquare) && > CurrentToken->isNot(tok::l_brace) && > - (!Parent || Parent->isOneOf(tok::colon, tok::l_square, tok::l_paren, > - tok::kw_return, tok::kw_throw) || > - Parent->isUnaryOperator() || Parent->Type == TT_ObjCForIn || > - Parent->Type == TT_CastRParen || > + (!Parent || > + Parent->isOneOf(tok::colon, tok::l_square, tok::l_paren, > + tok::kw_return, tok::kw_throw) || > + Parent->isUnaryOperator() || > + Parent->isOneOf(TT_ObjCForIn, TT_CastRParen) || > getBinOpPrecedence(Parent->Tok.getKind(), true, true) > > prec::Unknown); > ScopedContextCreator ContextCreator(*this, tok::l_square, 10); > Contexts.back().IsExpression = true; > @@ -255,14 +256,14 @@ private: > Left->Type = TT_ObjCMethodExpr; > } else if (Parent && Parent->is(tok::at)) { > Left->Type = TT_ArrayInitializerLSquare; > - } else if (Left->Type == TT_Unknown) { > + } else if (Left->is(TT_Unknown)) { > Left->Type = TT_ArraySubscriptLSquare; > } > > while (CurrentToken) { > if (CurrentToken->is(tok::r_square)) { > if (CurrentToken->Next && CurrentToken->Next->is(tok::l_paren) && > - Left->Type == TT_ObjCMethodExpr) { > + Left->is(TT_ObjCMethodExpr)) { > // An ObjC method call is rarely followed by an open parenthesis. > // FIXME: Do we incorrectly label ":" with this? > StartsObjCMethodExpr = false; > @@ -273,7 +274,7 @@ private: > // determineStarAmpUsage() thinks that '*' '[' is allocating an > // array of pointers, but if '[' starts a selector then '*' is a > // binary operator. > - if (Parent && Parent->Type == TT_PointerOrReference) > + if (Parent && Parent->is(TT_PointerOrReference)) > Parent->Type = TT_BinaryOperator; > } > Left->MatchingParen = CurrentToken; > @@ -290,7 +291,7 @@ private: > if (CurrentToken->isOneOf(tok::r_paren, tok::r_brace)) > return false; > if (CurrentToken->is(tok::colon)) { > - if (Left->Type == TT_ArraySubscriptLSquare) { > + if (Left->is(TT_ArraySubscriptLSquare)) { > Left->Type = TT_ObjCMethodExpr; > StartsObjCMethodExpr = true; > Contexts.back().ColonIsObjCMethodExpr = true; > @@ -301,8 +302,8 @@ private: > } > if (CurrentToken->is(tok::comma) && > Style.Language != FormatStyle::LK_Proto && > - (Left->Type == TT_ArraySubscriptLSquare || > - (Left->Type == TT_ObjCMethodExpr && !ColonFound))) > + (Left->is(TT_ArraySubscriptLSquare) || > + (Left->is(TT_ObjCMethodExpr) && !ColonFound))) > Left->Type = TT_ArrayInitializerLSquare; > FormatToken* Tok = CurrentToken; > if (!consumeToken()) > @@ -352,8 +353,8 @@ private: > } > > void updateParameterCount(FormatToken *Left, FormatToken *Current) { > - if (Current->Type == TT_LambdaLSquare || > - (Current->is(tok::caret) && Current->Type == TT_UnaryOperator) || > + if (Current->is(TT_LambdaLSquare) || > + (Current->is(tok::caret) && Current->is(TT_UnaryOperator)) || > (Style.Language == FormatStyle::LK_JavaScript && > Current->is(Keywords.kw_function))) { > ++Left->BlockParameterCount; > @@ -413,7 +414,7 @@ private: > } else if (Contexts.back().ColonIsDictLiteral) { > Tok->Type = TT_DictLiteral; > } else if (Contexts.back().ColonIsObjCMethodExpr || > - Line.First->Type == TT_ObjCMethodSpecifier) { > + Line.First->is(TT_ObjCMethodSpecifier)) { > Tok->Type = TT_ObjCMethodExpr; > Tok->Previous->Type = TT_SelectorName; > if (Tok->Previous->ColumnWidth > > @@ -456,8 +457,7 @@ private: > if (!parseParens()) > return false; > if (Line.MustBeDeclaration && Contexts.size() == 1 && > - !Contexts.back().IsExpression && > - Line.First->Type != TT_ObjCProperty && > + !Contexts.back().IsExpression && > Line.First->isNot(TT_ObjCProperty) && > (!Tok->Previous || Tok->Previous->isNot(tok::kw_decltype))) > Line.MightBeFunctionDecl = true; > break; > @@ -495,12 +495,12 @@ private: > if (CurrentToken->isOneOf(tok::star, tok::amp)) > CurrentToken->Type = TT_PointerOrReference; > consumeToken(); > - if (CurrentToken && CurrentToken->Previous->Type == > TT_BinaryOperator) > + if (CurrentToken && CurrentToken->Previous->is(TT_BinaryOperator)) > CurrentToken->Previous->Type = TT_OverloadedOperator; > } > if (CurrentToken) { > CurrentToken->Type = TT_OverloadedOperatorLParen; > - if (CurrentToken->Previous->Type == TT_BinaryOperator) > + if (CurrentToken->Previous->is(TT_BinaryOperator)) > CurrentToken->Previous->Type = TT_OverloadedOperator; > } > break; > @@ -641,7 +641,7 @@ public: > if (ImportStatement) > return LT_ImportStatement; > > - if (Line.First->Type == TT_ObjCMethodSpecifier) { > + if (Line.First->is(TT_ObjCMethodSpecifier)) { > if (Contexts.back().FirstObjCSelectorName) > Contexts.back().FirstObjCSelectorName->LongestObjCSelectorName = > Contexts.back().LongestObjCSelectorName; > @@ -668,11 +668,9 @@ private: > > // Reset token type in case we have already looked at it and then > // recovered from an error (e.g. failure to find the matching >). > - if (CurrentToken->Type != TT_LambdaLSquare && > - CurrentToken->Type != TT_FunctionLBrace && > - CurrentToken->Type != TT_ImplicitStringLiteral && > - CurrentToken->Type != TT_RegexLiteral && > - CurrentToken->Type != TT_TrailingReturnArrow) > + if (!CurrentToken->isOneOf(TT_LambdaLSquare, TT_FunctionLBrace, > + TT_ImplicitStringLiteral, TT_RegexLiteral, > + TT_TrailingReturnArrow)) > CurrentToken->Type = TT_Unknown; > CurrentToken->Role.reset(); > CurrentToken->FakeLParens.clear(); > @@ -683,6 +681,7 @@ private: > if (CurrentToken) { > CurrentToken->NestingLevel = Contexts.size() - 1; > CurrentToken->BindingStrength = Contexts.back().BindingStrength; > + modifyContext(*CurrentToken); > determineTokenType(*CurrentToken); > CurrentToken = CurrentToken->Next; > } > @@ -735,7 +734,7 @@ private: > ~ScopedContextCreator() { P.Contexts.pop_back(); } > }; > > - void determineTokenType(FormatToken &Current) { > + void modifyContext(const FormatToken &Current) { > if (Current.getPrecedence() == prec::Assignment && > !Line.First->isOneOf(tok::kw_template, tok::kw_using) && > (!Current.Previous || Current.Previous->isNot(tok::kw_operator))) { > @@ -748,8 +747,7 @@ private: > if (!Previous) > break; > } > - if ((Previous->Type == TT_BinaryOperator || > - Previous->Type == TT_UnaryOperator) && > + if ((Previous->isOneOf(TT_BinaryOperator, TT_UnaryOperator)) && > Previous->isOneOf(tok::star, tok::amp) && Previous->Previous && > Previous->Previous->isNot(tok::equal)) { > Previous->Type = TT_PointerOrReference; > @@ -766,7 +764,7 @@ private: > bool ParametersOfFunctionType = > Current.Previous && Current.Previous->is(tok::r_paren) && > Current.Previous->MatchingParen && > - Current.Previous->MatchingParen->Type == TT_FunctionTypeLParen; > + Current.Previous->MatchingParen->is(TT_FunctionTypeLParen); > bool IsForOrCatch = Current.Previous && > Current.Previous->isOneOf(tok::kw_for, > tok::kw_catch); > Contexts.back().IsExpression = !ParametersOfFunctionType && > !IsForOrCatch; > @@ -778,7 +776,7 @@ private: > if (Line.MustBeDeclaration) > Contexts.back().IsExpression = Contexts.front().InCtorInitializer; > } else if (Current.Previous && > - Current.Previous->Type == TT_CtorInitializerColon) { > + Current.Previous->is(TT_CtorInitializerColon)) { > Contexts.back().IsExpression = true; > Contexts.back().InCtorInitializer = true; > } else if (Current.is(tok::kw_new)) { > @@ -787,85 +785,87 @@ private: > // This should be the condition or increment in a for-loop. > Contexts.back().IsExpression = true; > } > + } > + > + void determineTokenType(FormatToken &Current) { > + if (!Current.is(TT_Unknown)) > + // The token type is already known. > + return; > > - if (Current.Type == TT_Unknown) { > + // Line.MightBeFunctionDecl can only be true after the parentheses of a > + // function declaration have been found. In this case, 'Current' is a > + // trailing token of this declaration and thus cannot be a name. > + if (isStartOfName(Current) && > + (!Line.MightBeFunctionDecl || Current.NestingLevel != 0)) { > + Contexts.back().FirstStartOfName = &Current; > + Current.Type = TT_StartOfName; > + } else if (Current.is(tok::kw_auto)) { > + AutoFound = true; > + } else if (Current.is(tok::arrow) && > + Style.Language == FormatStyle::LK_Java) { > + Current.Type = TT_LambdaArrow; > + } else if (Current.is(tok::arrow) && AutoFound && Line.MustBeDeclaration > && > + Current.NestingLevel == 0) { > + Current.Type = TT_TrailingReturnArrow; > + } else if (Current.isOneOf(tok::star, tok::amp, tok::ampamp)) { > + Current.Type = > + determineStarAmpUsage(Current, Contexts.back().CanBeExpression && > + Contexts.back().IsExpression, > + Contexts.back().InTemplateArgument); > + } else if (Current.isOneOf(tok::minus, tok::plus, tok::caret)) { > + Current.Type = determinePlusMinusCaretUsage(Current); > + if (Current.is(TT_UnaryOperator) && Current.is(tok::caret)) > + Contexts.back().CaretFound = true; > + } else if (Current.isOneOf(tok::minusminus, tok::plusplus)) { > + Current.Type = determineIncrementUsage(Current); > + } else if (Current.isOneOf(tok::exclaim, tok::tilde)) { > + Current.Type = TT_UnaryOperator; > + } else if (Current.is(tok::question)) { > + Current.Type = TT_ConditionalExpr; > + } else if (Current.isBinaryOperator() && > + (!Current.Previous || > Current.Previous->isNot(tok::l_square))) { > + Current.Type = TT_BinaryOperator; > + } else if (Current.is(tok::comment)) { > + if (Current.TokenText.startswith("//")) > + Current.Type = TT_LineComment; > + else > + Current.Type = TT_BlockComment; > + } else if (Current.is(tok::r_paren)) { > + if (rParenEndsCast(Current)) > + Current.Type = TT_CastRParen; > + } else if (Current.is(tok::at) && Current.Next) { > + switch (Current.Next->Tok.getObjCKeywordID()) { > + case tok::objc_interface: > + case tok::objc_implementation: > + case tok::objc_protocol: > + Current.Type = TT_ObjCDecl; > + break; > + case tok::objc_property: > + Current.Type = TT_ObjCProperty; > + break; > + default: > + break; > + } > + } else if (Current.is(tok::period)) { > + FormatToken *PreviousNoComment = Current.getPreviousNonComment(); > + if (PreviousNoComment && > + PreviousNoComment->isOneOf(tok::comma, tok::l_brace)) > + Current.Type = TT_DesignatedInitializerPeriod; > + } else if (Current.isOneOf(tok::identifier, tok::kw_const) && > + Current.Previous && > + !Current.Previous->isOneOf(tok::equal, tok::at) && > + Line.MightBeFunctionDecl && Contexts.size() == 1) { > // Line.MightBeFunctionDecl can only be true after the parentheses of a > - // function declaration have been found. In this case, 'Current' is a > - // trailing token of this declaration and thus cannot be a name. > - if (isStartOfName(Current) && > - (!Line.MightBeFunctionDecl || Current.NestingLevel != 0)) { > - Contexts.back().FirstStartOfName = &Current; > - Current.Type = TT_StartOfName; > - } else if (Current.is(tok::kw_auto)) { > - AutoFound = true; > - } else if (Current.is(tok::arrow) && > - Style.Language == FormatStyle::LK_Java) { > - Current.Type = TT_LambdaArrow; > - } else if (Current.is(tok::arrow) && AutoFound && > - Line.MustBeDeclaration && Current.NestingLevel == 0) { > - Current.Type = TT_TrailingReturnArrow; > - } else if (Current.isOneOf(tok::star, tok::amp, tok::ampamp)) { > - Current.Type = > - determineStarAmpUsage(Current, Contexts.back().CanBeExpression && > - Contexts.back().IsExpression, > - Contexts.back().InTemplateArgument); > - } else if (Current.isOneOf(tok::minus, tok::plus, tok::caret)) { > - Current.Type = determinePlusMinusCaretUsage(Current); > - if (Current.Type == TT_UnaryOperator && Current.is(tok::caret)) > - Contexts.back().CaretFound = true; > - } else if (Current.isOneOf(tok::minusminus, tok::plusplus)) { > - Current.Type = determineIncrementUsage(Current); > - } else if (Current.isOneOf(tok::exclaim, tok::tilde)) { > - Current.Type = TT_UnaryOperator; > - } else if (Current.is(tok::question)) { > - Current.Type = TT_ConditionalExpr; > - } else if (Current.isBinaryOperator() && > - (!Current.Previous || > - Current.Previous->isNot(tok::l_square))) { > - Current.Type = TT_BinaryOperator; > - } else if (Current.is(tok::comment)) { > - if (Current.TokenText.startswith("//")) > - Current.Type = TT_LineComment; > - else > - Current.Type = TT_BlockComment; > - } else if (Current.is(tok::r_paren)) { > - if (rParenEndsCast(Current)) > - Current.Type = TT_CastRParen; > - } else if (Current.is(tok::at) && Current.Next) { > - switch (Current.Next->Tok.getObjCKeywordID()) { > - case tok::objc_interface: > - case tok::objc_implementation: > - case tok::objc_protocol: > - Current.Type = TT_ObjCDecl; > - break; > - case tok::objc_property: > - Current.Type = TT_ObjCProperty; > - break; > - default: > - break; > - } > - } else if (Current.is(tok::period)) { > - FormatToken *PreviousNoComment = Current.getPreviousNonComment(); > - if (PreviousNoComment && > - PreviousNoComment->isOneOf(tok::comma, tok::l_brace)) > - Current.Type = TT_DesignatedInitializerPeriod; > - } else if (Current.isOneOf(tok::identifier, tok::kw_const) && > - Current.Previous && > - !Current.Previous->isOneOf(tok::equal, tok::at) && > - Line.MightBeFunctionDecl && Contexts.size() == 1) { > - // Line.MightBeFunctionDecl can only be true after the parentheses > of a > - // function declaration have been found. > - Current.Type = TT_TrailingAnnotation; > - } else if (Style.Language == FormatStyle::LK_Java && Current.Previous > && > - Current.Previous->is(tok::at) && > - Current.isNot(Keywords.kw_interface)) { > - const FormatToken& AtToken = *Current.Previous; > - if (!AtToken.Previous || > - AtToken.Previous->Type == TT_LeadingJavaAnnotation) > - Current.Type = TT_LeadingJavaAnnotation; > - else > - Current.Type = TT_JavaAnnotation; > - } > + // function declaration have been found. > + Current.Type = TT_TrailingAnnotation; > + } else if (Style.Language == FormatStyle::LK_Java && Current.Previous && > + Current.Previous->is(tok::at) && > + Current.isNot(Keywords.kw_interface)) { > + const FormatToken &AtToken = *Current.Previous; > + if (!AtToken.Previous || > AtToken.Previous->is(TT_LeadingJavaAnnotation)) > + Current.Type = TT_LeadingJavaAnnotation; > + else > + Current.Type = TT_JavaAnnotation; > } > } > > @@ -890,7 +890,7 @@ private: > PreviousNotConst->Previous && > PreviousNotConst->Previous->is(tok::hash); > > - if (PreviousNotConst->Type == TT_TemplateCloser) > + if (PreviousNotConst->is(TT_TemplateCloser)) > return PreviousNotConst && PreviousNotConst->MatchingParen && > PreviousNotConst->MatchingParen->Previous && > PreviousNotConst->MatchingParen->Previous->isNot(tok::period) && > @@ -902,7 +902,7 @@ private: > return true; > > return (!IsPPKeyword && PreviousNotConst->is(tok::identifier)) || > - PreviousNotConst->Type == TT_PointerOrReference || > + PreviousNotConst->is(TT_PointerOrReference) || > PreviousNotConst->isSimpleTypeSpecifier(); > } > > @@ -916,14 +916,14 @@ private: > LeftOfParens = LeftOfParens->MatchingParen->Previous; > if (LeftOfParens && LeftOfParens->is(tok::r_square) && > LeftOfParens->MatchingParen && > - LeftOfParens->MatchingParen->Type == TT_LambdaLSquare) > + LeftOfParens->MatchingParen->is(TT_LambdaLSquare)) > return false; > bool IsCast = false; > bool ParensAreEmpty = Tok.Previous == Tok.MatchingParen; > - bool ParensAreType = !Tok.Previous || > - Tok.Previous->Type == TT_PointerOrReference || > - Tok.Previous->Type == TT_TemplateCloser || > - Tok.Previous->isSimpleTypeSpecifier(); > + bool ParensAreType = > + !Tok.Previous || > + Tok.Previous->isOneOf(TT_PointerOrReference, TT_TemplateCloser) || > + Tok.Previous->isSimpleTypeSpecifier(); > if (Style.Language == FormatStyle::LK_JavaScript && Tok.Next && > Tok.Next->is(Keywords.kw_in)) > return false; > @@ -941,12 +941,11 @@ private: > IsCast = true; > // If there is an identifier after the (), it is likely a cast, unless > // there is also an identifier before the (). > - else if (LeftOfParens && > + else if (LeftOfParens && Tok.Next && > (LeftOfParens->Tok.getIdentifierInfo() == nullptr || > LeftOfParens->is(tok::kw_return)) && > - LeftOfParens->Type != TT_OverloadedOperator && > - LeftOfParens->isNot(tok::at) && > - LeftOfParens->Type != TT_TemplateCloser && Tok.Next) { > + !LeftOfParens->isOneOf(TT_OverloadedOperator, tok::at, > + TT_TemplateCloser)) { > if (Tok.Next->isOneOf(tok::identifier, tok::numeric_constant)) { > IsCast = true; > } else { > @@ -994,13 +993,12 @@ private: > > if (PrevToken->isOneOf(tok::l_paren, tok::l_square, tok::l_brace, > tok::comma, tok::semi, tok::kw_return, tok::colon, > - tok::equal, tok::kw_delete, tok::kw_sizeof) || > - PrevToken->Type == TT_BinaryOperator || > - PrevToken->Type == TT_ConditionalExpr || > - PrevToken->Type == TT_UnaryOperator || PrevToken->Type == > TT_CastRParen) > + tok::equal, tok::kw_delete, tok::kw_sizeof, > + TT_BinaryOperator, TT_ConditionalExpr, > + TT_UnaryOperator, TT_CastRParen)) > return TT_UnaryOperator; > > - if (NextToken->is(tok::l_square) && NextToken->Type != TT_LambdaLSquare) > + if (NextToken->is(tok::l_square) && NextToken->isNot(TT_LambdaLSquare)) > return TT_PointerOrReference; > if (NextToken->isOneOf(tok::kw_operator, tok::comma)) > return TT_PointerOrReference; > @@ -1043,7 +1041,7 @@ private: > > TokenType determinePlusMinusCaretUsage(const FormatToken &Tok) { > const FormatToken *PrevToken = Tok.getPreviousNonComment(); > - if (!PrevToken || PrevToken->Type == TT_CastRParen) > + if (!PrevToken || PrevToken->is(TT_CastRParen)) > return TT_UnaryOperator; > > // Use heuristics to recognize unary operators. > @@ -1053,7 +1051,7 @@ private: > return TT_UnaryOperator; > > // There can't be two consecutive binary operators. > - if (PrevToken->Type == TT_BinaryOperator) > + if (PrevToken->is(TT_BinaryOperator)) > return TT_UnaryOperator; > > // Fall back to marking the token as binary operator. > @@ -1063,7 +1061,7 @@ private: > /// \brief Determine whether ++/-- are pre- or post-increments/-decrements. > TokenType determineIncrementUsage(const FormatToken &Tok) { > const FormatToken *PrevToken = Tok.getPreviousNonComment(); > - if (!PrevToken || PrevToken->Type == TT_CastRParen) > + if (!PrevToken || PrevToken->is(TT_CastRParen)) > return TT_UnaryOperator; > if (PrevToken->isOneOf(tok::r_paren, tok::r_square, tok::identifier)) > return TT_TrailingUnaryOperator; > @@ -1095,10 +1093,9 @@ public: > void parse(int Precedence = 0) { > // Skip 'return' and ObjC selector colons as they are not part of a > binary > // expression. > - while (Current && > - (Current->is(tok::kw_return) || > - (Current->is(tok::colon) && (Current->Type == TT_ObjCMethodExpr > || > - Current->Type == TT_DictLiteral)))) > + while (Current && (Current->is(tok::kw_return) || > + (Current->is(tok::colon) && > + Current->isOneOf(TT_ObjCMethodExpr, > TT_DictLiteral)))) > next(); > > if (!Current || Precedence > PrecedenceArrowAndPeriod) > @@ -1127,7 +1124,7 @@ public: > > int CurrentPrecedence = getCurrentPrecedence(); > > - if (Current && Current->Type == TT_SelectorName && > + if (Current && Current->is(TT_SelectorName) && > Precedence == CurrentPrecedence) { > if (LatestOperator) > addFakeParenthesis(Start, prec::Level(Precedence)); > @@ -1177,21 +1174,21 @@ private: > int getCurrentPrecedence() { > if (Current) { > const FormatToken *NextNonComment = Current->getNextNonComment(); > - if (Current->Type == TT_ConditionalExpr) > + if (Current->is(TT_ConditionalExpr)) > return prec::Conditional; > else if (NextNonComment && NextNonComment->is(tok::colon) && > - NextNonComment->Type == TT_DictLiteral) > + NextNonComment->is(TT_DictLiteral)) > return prec::Comma; > else if (Current->is(TT_LambdaArrow)) > return prec::Comma; > - else if (Current->is(tok::semi) || Current->Type == TT_InlineASMColon > || > - Current->Type == TT_SelectorName || > + else if (Current->isOneOf(tok::semi, TT_InlineASMColon, > + TT_SelectorName) || > (Current->is(tok::comment) && NextNonComment && > - NextNonComment->Type == TT_SelectorName)) > + NextNonComment->is(TT_SelectorName))) > return 0; > - else if (Current->Type == TT_RangeBasedForLoopColon) > + else if (Current->is(TT_RangeBasedForLoopColon)) > return prec::Comma; > - else if (Current->Type == TT_BinaryOperator || Current->is(tok::comma)) > + else if (Current->is(TT_BinaryOperator) || Current->is(tok::comma)) > return Current->getPrecedence(); > else if (Current->isOneOf(tok::period, tok::arrow)) > return PrecedenceArrowAndPeriod; > @@ -1219,7 +1216,7 @@ private: > /// \brief Parse unary operator expressions and surround them with fake > /// parentheses if appropriate. > void parseUnaryOperator() { > - if (!Current || Current->Type != TT_UnaryOperator) { > + if (!Current || Current->isNot(TT_UnaryOperator)) { > parse(PrecedenceArrowAndPeriod); > return; > } > @@ -1242,7 +1239,7 @@ private: > return; > next(); > parse(prec::Assignment); > - if (!Current || Current->Type != TT_ConditionalExpr) > + if (!Current || Current->isNot(TT_ConditionalExpr)) > return; > next(); > parse(prec::Assignment); > @@ -1295,11 +1292,11 @@ void TokenAnnotator::annotate(AnnotatedL > ExpressionParser ExprParser(Style, Keywords, Line); > ExprParser.parse(); > > - if (Line.First->Type == TT_ObjCMethodSpecifier) > + if (Line.First->is(TT_ObjCMethodSpecifier)) > Line.Type = LT_ObjCMethodDecl; > - else if (Line.First->Type == TT_ObjCDecl) > + else if (Line.First->is(TT_ObjCDecl)) > Line.Type = LT_ObjCDecl; > - else if (Line.First->Type == TT_ObjCProperty) > + else if (Line.First->is(TT_ObjCProperty)) > Line.Type = LT_ObjCProperty; > > Line.First->SpacesRequiredBefore = 1; > @@ -1309,12 +1306,11 @@ void TokenAnnotator::annotate(AnnotatedL > // This function heuristically determines whether 'Current' starts the name > of a > // function declaration. > static bool isFunctionDeclarationName(const FormatToken &Current) { > - if (Current.Type != TT_StartOfName || > - Current.NestingLevel != 0) > + if (!Current.is(TT_StartOfName) || Current.NestingLevel != 0) > return false; > const FormatToken *Next = Current.Next; > for (; Next; Next = Next->Next) { > - if (Next->Type == TT_TemplateOpener) { > + if (Next->is(TT_TemplateOpener)) { > Next = Next->MatchingParen; > } else if (Next->is(tok::coloncolon)) { > Next = Next->Next; > @@ -1334,7 +1330,7 @@ static bool isFunctionDeclarationName(co > for (const FormatToken *Tok = Next->Next; Tok != Next->MatchingParen; > Tok = Tok->Next) { > if (Tok->is(tok::kw_const) || Tok->isSimpleTypeSpecifier() || > - Tok->Type == TT_PointerOrReference || Tok->Type == TT_StartOfName) > + Tok->isOneOf(TT_PointerOrReference, TT_StartOfName)) > return true; > if (Tok->isOneOf(tok::l_brace, tok::string_literal) || > Tok->Tok.isLiteral()) > return false; > @@ -1358,7 +1354,7 @@ void TokenAnnotator::calculateFormatting > while (Current) { > if (isFunctionDeclarationName(*Current)) > Current->Type = TT_FunctionDeclarationName; > - if (Current->Type == TT_LineComment) { > + if (Current->is(TT_LineComment)) { > if (Current->Previous->BlockKind == BK_BracedInit && > Current->Previous->opensScope()) > Current->SpacesRequiredBefore = Style.Cpp11BracedListStyle ? 0 : 1; > @@ -1378,7 +1374,7 @@ void TokenAnnotator::calculateFormatting > if (Parameter->isOneOf(tok::comment, tok::r_brace)) > break; > if (Parameter->Previous && Parameter->Previous->is(tok::comma)) { > - if (Parameter->Previous->Type != TT_CtorInitializerComma && > + if (!Parameter->Previous->is(TT_CtorInitializerComma) && > Parameter->HasUnescapedNewline) > Parameter->MustBreakBefore = true; > break; > @@ -1394,7 +1390,7 @@ void TokenAnnotator::calculateFormatting > Current->MustBreakBefore || mustBreakBefore(Line, *Current); > > if (Style.AlwaysBreakAfterDefinitionReturnType && > - InFunctionDecl && Current->Type == TT_FunctionDeclarationName && > + InFunctionDecl && Current->is(TT_FunctionDeclarationName) && > !Line.Last->isOneOf(tok::semi, tok::comment)) // Only for > definitions. > // FIXME: Line.Last points to other characters than tok::semi > // and tok::lbrace. > @@ -1418,7 +1414,7 @@ void TokenAnnotator::calculateFormatting > Current->TotalLength = Prev->TotalLength + Current->ColumnWidth + > ChildSize + Current->SpacesRequiredBefore; > > - if (Current->Type == TT_CtorInitializerColon) > + if (Current->is(TT_CtorInitializerColon)) > InFunctionDecl = false; > > // FIXME: Only calculate this if CanBreakBefore is true once static > @@ -1465,7 +1461,7 @@ unsigned TokenAnnotator::splitPenalty(co > return 0; > > if (Style.Language == FormatStyle::LK_Java) { > - if (Left.Type == TT_LeadingJavaAnnotation) > + if (Left.is(TT_LeadingJavaAnnotation)) > return 1; > if (Right.is(Keywords.kw_extends)) > return 1; > @@ -1476,20 +1472,20 @@ unsigned TokenAnnotator::splitPenalty(co > } > > if (Left.is(tok::comma) || (Right.is(tok::identifier) && Right.Next && > - Right.Next->Type == TT_DictLiteral)) > + Right.Next->is(TT_DictLiteral))) > return 1; > if (Right.is(tok::l_square)) { > if (Style.Language == FormatStyle::LK_Proto) > return 1; > - if (Right.Type != TT_ObjCMethodExpr && Right.Type != TT_LambdaLSquare) > + if (!Right.isOneOf(TT_ObjCMethodExpr, TT_LambdaLSquare)) > return 500; > } > > - if (Right.Type == TT_StartOfName || > - Right.Type == TT_FunctionDeclarationName || > Right.is(tok::kw_operator)) { > + if (Right.isOneOf(TT_StartOfName, TT_FunctionDeclarationName) || > + Right.is(tok::kw_operator)) { > if (Line.First->is(tok::kw_for) && Right.PartOfMultiVariableDeclStmt) > return 3; > - if (Left.Type == TT_StartOfName) > + if (Left.is(TT_StartOfName)) > return 20; > if (InFunctionDecl && Right.NestingLevel == 0) > return Style.PenaltyReturnTypeOnItsOwnLine; > @@ -1497,7 +1493,7 @@ unsigned TokenAnnotator::splitPenalty(co > } > if (Left.is(tok::equal) && Right.is(tok::l_brace)) > return 150; > - if (Left.Type == TT_CastRParen) > + if (Left.is(TT_CastRParen)) > return 100; > if (Left.is(tok::coloncolon) || > (Right.is(tok::period) && Style.Language == FormatStyle::LK_Proto)) > @@ -1505,8 +1501,7 @@ unsigned TokenAnnotator::splitPenalty(co > if (Left.isOneOf(tok::kw_class, tok::kw_struct)) > return 5000; > > - if (Left.Type == TT_RangeBasedForLoopColon || > - Left.Type == TT_InheritanceColon) > + if (Left.isOneOf(TT_RangeBasedForLoopColon, TT_InheritanceColon)) > return 2; > > if (Right.isMemberAccess()) { > @@ -1516,11 +1511,11 @@ unsigned TokenAnnotator::splitPenalty(co > return 150; > } > > - if (Right.Type == TT_TrailingAnnotation && > + if (Right.is(TT_TrailingAnnotation) && > (!Right.Next || Right.Next->isNot(tok::l_paren))) { > // Moving trailing annotations to the next line is fine for ObjC method > // declarations. > - if (Line.First->Type == TT_ObjCMethodSpecifier) > + if (Line.First->is(TT_ObjCMethodSpecifier)) > > return 10; > // Generally, breaking before a trailing annotation is bad unless it is > @@ -1538,9 +1533,9 @@ unsigned TokenAnnotator::splitPenalty(co > > // In Objective-C method expressions, prefer breaking before "param:" over > // breaking after it. > - if (Right.Type == TT_SelectorName) > + if (Right.is(TT_SelectorName)) > return 0; > - if (Left.is(tok::colon) && Left.Type == TT_ObjCMethodExpr) > + if (Left.is(tok::colon) && Left.is(TT_ObjCMethodExpr)) > return Line.MightBeFunctionDecl ? 50 : 500; > > if (Left.is(tok::l_paren) && InFunctionDecl && Style.AlignAfterOpenBracket) > @@ -1549,7 +1544,7 @@ unsigned TokenAnnotator::splitPenalty(co > return 110; > if (Right.is(tok::r_brace)) > return 1; > - if (Left.Type == TT_TemplateOpener) > + if (Left.is(TT_TemplateOpener)) > return 100; > if (Left.opensScope()) { > if (!Style.AlignAfterOpenBracket) > @@ -1572,7 +1567,7 @@ unsigned TokenAnnotator::splitPenalty(co > } > return 1; // Breaking at a << is really cheap. > } > - if (Left.Type == TT_ConditionalExpr) > + if (Left.is(TT_ConditionalExpr)) > return prec::Conditional; > prec::Level Level = Left.getPrecedence(); > > @@ -1597,8 +1592,8 @@ bool TokenAnnotator::spaceRequiredBetwee > if (Left.is(tok::l_paren) && Right.is(tok::r_paren)) > return Style.SpaceInEmptyParentheses; > if (Left.is(tok::l_paren) || Right.is(tok::r_paren)) > - return (Right.Type == TT_CastRParen || > - (Left.MatchingParen && Left.MatchingParen->Type == > TT_CastRParen)) > + return (Right.is(TT_CastRParen )|| > + (Left.MatchingParen && Left.MatchingParen->is(TT_CastRParen))) > ? Style.SpacesInCStyleCastParentheses > : Style.SpacesInParentheses; > if (Right.isOneOf(tok::semi, tok::comma)) > @@ -1622,49 +1617,48 @@ bool TokenAnnotator::spaceRequiredBetwee > return Left.Tok.isLiteral(); > if (Left.is(tok::l_square) && Right.is(tok::amp)) > return false; > - if (Right.Type == TT_PointerOrReference) > + if (Right.is(TT_PointerOrReference)) > return Left.Tok.isLiteral() || > - ((Left.Type != TT_PointerOrReference) && Left.isNot(tok::l_paren) > && > + (!Left.isOneOf(TT_PointerOrReference, tok::l_paren) && > Style.PointerAlignment != FormatStyle::PAS_Left); > - if (Right.Type == TT_FunctionTypeLParen && Left.isNot(tok::l_paren) && > - (Left.Type != TT_PointerOrReference || > + if (Right.is(TT_FunctionTypeLParen) && Left.isNot(tok::l_paren) && > + (!Left.is(TT_PointerOrReference) || > Style.PointerAlignment != FormatStyle::PAS_Right)) > return true; > - if (Left.Type == TT_PointerOrReference) > - return Right.Tok.isLiteral() || Right.Type == TT_BlockComment || > - ((Right.Type != TT_PointerOrReference) && > - Right.isNot(tok::l_paren) && > + if (Left.is(TT_PointerOrReference)) > + return Right.Tok.isLiteral() || Right.is(TT_BlockComment) || > + (!Right.isOneOf(TT_PointerOrReference, tok::l_paren) && > Style.PointerAlignment != FormatStyle::PAS_Right && > Left.Previous && > !Left.Previous->isOneOf(tok::l_paren, tok::coloncolon)); > if (Right.is(tok::star) && Left.is(tok::l_paren)) > return false; > if (Left.is(tok::l_square)) > - return (Left.Type == TT_ArrayInitializerLSquare && > + return (Left.is(TT_ArrayInitializerLSquare) && > Style.SpacesInContainerLiterals && Right.isNot(tok::r_square)) || > - (Left.Type == TT_ArraySubscriptLSquare && > - Style.SpacesInSquareBrackets && Right.isNot(tok::r_square)); > + (Left.is(TT_ArraySubscriptLSquare) && > Style.SpacesInSquareBrackets && > + Right.isNot(tok::r_square)); > if (Right.is(tok::r_square)) > return Right.MatchingParen && > ((Style.SpacesInContainerLiterals && > - Right.MatchingParen->Type == TT_ArrayInitializerLSquare) || > + Right.MatchingParen->is(TT_ArrayInitializerLSquare)) || > (Style.SpacesInSquareBrackets && > - Right.MatchingParen->Type == TT_ArraySubscriptLSquare)); > - if (Right.is(tok::l_square) && Right.Type != TT_ObjCMethodExpr && > - Right.Type != TT_LambdaLSquare && Left.isNot(tok::numeric_constant) && > - Left.Type != TT_DictLiteral) > + Right.MatchingParen->is(TT_ArraySubscriptLSquare))); > + if (Right.is(tok::l_square) && > + !Right.isOneOf(TT_ObjCMethodExpr, TT_LambdaLSquare) && > + !Left.isOneOf(tok::numeric_constant, TT_DictLiteral)) > return false; > if (Left.is(tok::colon)) > - return Left.Type != TT_ObjCMethodExpr; > + return !Left.is(TT_ObjCMethodExpr); > if (Left.is(tok::l_brace) && Right.is(tok::r_brace)) > return !Left.Children.empty(); // No spaces in "{}". > if ((Left.is(tok::l_brace) && Left.BlockKind != BK_Block) || > (Right.is(tok::r_brace) && Right.MatchingParen && > Right.MatchingParen->BlockKind != BK_Block)) > return !Style.Cpp11BracedListStyle; > - if (Left.Type == TT_BlockComment) > + if (Left.is(TT_BlockComment)) > return !Left.TokenText.endswith("=*/"); > if (Right.is(tok::l_paren)) { > - if (Left.is(tok::r_paren) && Left.Type == TT_AttributeParen) > + if (Left.is(tok::r_paren) && Left.is(TT_AttributeParen)) > return true; > return Line.Type == LT_ObjCDecl || > Left.isOneOf(tok::kw_new, tok::kw_delete, tok::semi) || > @@ -1680,9 +1674,9 @@ bool TokenAnnotator::spaceRequiredBetwee > } > if (Left.is(tok::at) && Right.Tok.getObjCKeywordID() != > tok::objc_not_keyword) > return false; > - if (Right.Type == TT_UnaryOperator) > + if (Right.is(TT_UnaryOperator)) > return !Left.isOneOf(tok::l_paren, tok::l_square, tok::at) && > - (Left.isNot(tok::colon) || Left.Type != TT_ObjCMethodExpr); > + (Left.isNot(tok::colon) || Left.isNot(TT_ObjCMethodExpr)); > if ((Left.isOneOf(tok::identifier, tok::greater, tok::r_square, > tok::r_paren) || > Left.isSimpleTypeSpecifier()) && > @@ -1693,12 +1687,12 @@ bool TokenAnnotator::spaceRequiredBetwee > return false; > if (Right.is(tok::hash) && Left.is(tok::identifier) && Left.TokenText == > "L") > return false; > - if (Left.Type == TT_TemplateCloser && Left.MatchingParen && > + if (Left.is(TT_TemplateCloser) && Left.MatchingParen && > Left.MatchingParen->Previous && > Left.MatchingParen->Previous->is(tok::period)) > // A.<B>DoSomething(); > return false; > - if (Left.Type == TT_TemplateCloser && Right.is(tok::l_square)) > + if (Left.is(TT_TemplateCloser) && Right.is(tok::l_square)) > return false; > return true; > } > @@ -1725,15 +1719,15 @@ bool TokenAnnotator::spaceRequiredBefore > if ((Left.isOneOf(tok::kw_static, tok::kw_public, tok::kw_private, > tok::kw_protected) || > Left.isOneOf(Keywords.kw_final, Keywords.kw_abstract)) && > - Right.Type == TT_TemplateOpener) > + Right.is(TT_TemplateOpener)) > return true; > } > if (Right.Tok.getIdentifierInfo() && Left.Tok.getIdentifierInfo()) > return true; // Never ever merge two identifiers. > - if (Left.Type == TT_ImplicitStringLiteral) > + if (Left.is(TT_ImplicitStringLiteral)) > return Right.WhitespaceRange.getBegin() != > Right.WhitespaceRange.getEnd(); > if (Line.Type == LT_ObjCMethodDecl) { > - if (Left.Type == TT_ObjCMethodSpecifier) > + if (Left.is(TT_ObjCMethodSpecifier)) > return true; > if (Left.is(tok::r_paren) && Right.is(tok::identifier)) > // Don't space between ')' and <id> > @@ -1743,31 +1737,30 @@ bool TokenAnnotator::spaceRequiredBefore > (Right.is(tok::equal) || Left.is(tok::equal))) > return false; > > - if (Right.Type == TT_TrailingReturnArrow || > - Left.Type == TT_TrailingReturnArrow) > + if (Right.is(TT_TrailingReturnArrow) || Left.is(TT_TrailingReturnArrow)) > return true; > if (Left.is(tok::comma)) > return true; > if (Right.is(tok::comma)) > return false; > - if (Right.Type == TT_CtorInitializerColon || Right.Type == > TT_ObjCBlockLParen) > + if (Right.isOneOf(TT_CtorInitializerColon, TT_ObjCBlockLParen)) > return true; > if (Left.is(tok::kw_operator)) > return Right.is(tok::coloncolon); > - if (Right.Type == TT_OverloadedOperatorLParen) > + if (Right.is(TT_OverloadedOperatorLParen)) > return false; > if (Right.is(tok::colon)) > return !Line.First->isOneOf(tok::kw_case, tok::kw_default) && > - Right.getNextNonComment() && Right.Type != TT_ObjCMethodExpr && > + Right.getNextNonComment() && Right.isNot(TT_ObjCMethodExpr) && > !Left.is(tok::question) && > - !(Right.Type == TT_InlineASMColon && Left.is(tok::coloncolon)) && > - (Right.Type != TT_DictLiteral || Style.SpacesInContainerLiterals); > - if (Left.Type == TT_UnaryOperator) > - return Right.Type == TT_BinaryOperator; > - if (Left.Type == TT_CastRParen) > - return Style.SpaceAfterCStyleCast || Right.Type == TT_BinaryOperator; > + !(Right.is(TT_InlineASMColon) && Left.is(tok::coloncolon)) && > + (Right.isNot(TT_DictLiteral) || Style.SpacesInContainerLiterals); > + if (Left.is(TT_UnaryOperator)) > + return Right.is(TT_BinaryOperator); > + if (Left.is(TT_CastRParen)) > + return Style.SpaceAfterCStyleCast || Right.is(TT_BinaryOperator); > if (Left.is(tok::greater) && Right.is(tok::greater)) { > - return Right.Type == TT_TemplateCloser && Left.Type == TT_TemplateCloser > && > + return Right.is(TT_TemplateCloser) && Left.is(TT_TemplateCloser) && > (Style.Standard != FormatStyle::LS_Cpp11 || Style.SpacesInAngles); > } > if (Right.isOneOf(tok::arrow, tok::period, tok::arrowstar, > tok::periodstar) || > @@ -1777,27 +1770,26 @@ bool TokenAnnotator::spaceRequiredBefore > Right.getPrecedence() == prec::Assignment) > return false; > if (Right.is(tok::coloncolon) && Left.isNot(tok::l_brace)) > - return (Left.Type == TT_TemplateOpener && > + return (Left.is(TT_TemplateOpener) && > Style.Standard == FormatStyle::LS_Cpp03) || > !(Left.isOneOf(tok::identifier, tok::l_paren, tok::r_paren) || > - Left.Type == TT_TemplateCloser || Left.Type == > TT_TemplateOpener); > - if ((Left.Type == TT_TemplateOpener) != (Right.Type == TT_TemplateCloser)) > + Left.isOneOf(TT_TemplateCloser, TT_TemplateOpener)); > + if ((Left.is(TT_TemplateOpener)) != (Right.is(TT_TemplateCloser))) > return Style.SpacesInAngles; > - if ((Right.Type == TT_BinaryOperator && !Left.is(tok::l_paren)) || > - Left.Type == TT_BinaryOperator || Left.Type == TT_ConditionalExpr) > + if ((Right.is(TT_BinaryOperator) && !Left.is(tok::l_paren)) || > + Left.isOneOf(TT_BinaryOperator, TT_ConditionalExpr)) > return true; > - if (Left.Type == TT_TemplateCloser && Right.is(tok::l_paren)) > + if (Left.is(TT_TemplateCloser) && Right.is(tok::l_paren)) > return Style.SpaceBeforeParens == FormatStyle::SBPO_Always; > - if (Right.Type == TT_TemplateOpener && Left.is(tok::r_paren) && > - Left.MatchingParen && > - Left.MatchingParen->Type == TT_OverloadedOperatorLParen) > + if (Right.is(TT_TemplateOpener) && Left.is(tok::r_paren) && > + Left.MatchingParen && > Left.MatchingParen->is(TT_OverloadedOperatorLParen)) > return false; > if (Right.is(tok::less) && Left.isNot(tok::l_paren) && > Line.First->is(tok::hash)) > return true; > - if (Right.Type == TT_TrailingUnaryOperator) > + if (Right.is(TT_TrailingUnaryOperator)) > return false; > - if (Left.Type == TT_RegexLiteral) > + if (Left.is(TT_RegexLiteral)) > return false; > return spaceRequiredBetween(Line, Left, Right); > } > @@ -1805,7 +1797,7 @@ bool TokenAnnotator::spaceRequiredBefore > // Returns 'true' if 'Tok' is a brace we'd want to break before in Allman > style. > static bool isAllmanBrace(const FormatToken &Tok) { > return Tok.is(tok::l_brace) && Tok.BlockKind == BK_Block && > - Tok.Type != TT_ObjCBlockLBrace && Tok.Type != TT_DictLiteral; > + !Tok.isOneOf(TT_ObjCBlockLBrace, TT_DictLiteral); > } > > bool TokenAnnotator::mustBreakBefore(const AnnotatedLine &Line, > @@ -1828,7 +1820,7 @@ bool TokenAnnotator::mustBreakBefore(con > > if (Right.is(tok::comment)) { > return Left.BlockKind != BK_BracedInit && > - Left.Type != TT_CtorInitializerColon && > + Left.isNot(TT_CtorInitializerColon) && > (Right.NewlinesBefore > 0 && Right.HasUnescapedNewline); > } else if (Right.Previous->isTrailingComment() || > (Right.isStringLiteral() && Right.Previous->isStringLiteral())) > { > @@ -1844,8 +1836,8 @@ bool TokenAnnotator::mustBreakBefore(con > Right.Previous->MatchingParen->NestingLevel == 0 && > Style.AlwaysBreakTemplateDeclarations) { > return true; > - } else if ((Right.Type == TT_CtorInitializerComma || > - Right.Type == TT_CtorInitializerColon) && > + } else if ((Right.isOneOf(TT_CtorInitializerComma, > + TT_CtorInitializerColon)) && > Style.BreakConstructorInitializersBeforeComma && > !Style.ConstructorInitializerAllOnOneLineOrOnePerLine) { > return true; > @@ -1870,9 +1862,9 @@ bool TokenAnnotator::mustBreakBefore(con > return Style.BreakBeforeBraces == FormatStyle::BS_Allman || > Style.BreakBeforeBraces == FormatStyle::BS_GNU; > } else if (Style.Language == FormatStyle::LK_Proto && > - Left.isNot(tok::l_brace) && Right.Type == TT_SelectorName) { > + Left.isNot(tok::l_brace) && Right.is(TT_SelectorName)) { > return true; > - } else if (Left.Type == TT_ObjCBlockLBrace && > + } else if (Left.is(TT_ObjCBlockLBrace) && > !Style.AllowShortBlocksOnASingleLine) { > return true; > } > @@ -1883,7 +1875,7 @@ bool TokenAnnotator::mustBreakBefore(con > Left.Previous->is(tok::char_constant)) > return true; > } else if (Style.Language == FormatStyle::LK_Java) { > - if (Left.Type == TT_LeadingJavaAnnotation && Right.isNot(tok::l_paren) && > + if (Left.is(TT_LeadingJavaAnnotation) && Right.isNot(tok::l_paren) && > Line.Last->is(tok::l_brace)) > return true; > if (Right.is(tok::plus) && Left.is(tok::string_literal) && Right.Next && > @@ -1911,10 +1903,10 @@ bool TokenAnnotator::canBreakBefore(cons > return false; > if (Left.Tok.getObjCKeywordID() == tok::objc_interface) > return false; > - if (Left.Type == TT_JavaAnnotation || Left.Type == > TT_LeadingJavaAnnotation) > + if (Left.isOneOf(TT_JavaAnnotation, TT_LeadingJavaAnnotation)) > return true; > - if (Right.Type == TT_StartOfName || > - Right.Type == TT_FunctionDeclarationName || Right.is(tok::kw_operator)) > + if (Right.isOneOf(TT_StartOfName, TT_FunctionDeclarationName) || > + Right.is(tok::kw_operator)) > return true; > if (Right.isTrailingComment()) > // We rely on MustBreakBefore being set correctly here as we should not > @@ -1925,47 +1917,46 @@ bool TokenAnnotator::canBreakBefore(cons > return Left.BlockKind == BK_BracedInit; > if (Left.is(tok::question) && Right.is(tok::colon)) > return false; > - if (Right.Type == TT_ConditionalExpr || Right.is(tok::question)) > + if (Right.is(TT_ConditionalExpr) || Right.is(tok::question)) > return Style.BreakBeforeTernaryOperators; > - if (Left.Type == TT_ConditionalExpr || Left.is(tok::question)) > + if (Left.is(TT_ConditionalExpr) || Left.is(tok::question)) > return !Style.BreakBeforeTernaryOperators; > - if (Right.Type == TT_InheritanceColon) > + if (Right.is(TT_InheritanceColon)) > return true; > - if (Right.is(tok::colon) && (Right.Type != TT_CtorInitializerColon && > - Right.Type != TT_InlineASMColon)) > + if (Right.is(tok::colon) && > + !Right.isOneOf(TT_CtorInitializerColon, TT_InlineASMColon)) > return false; > - if (Left.is(tok::colon) && > - (Left.Type == TT_DictLiteral || Left.Type == TT_ObjCMethodExpr)) > + if (Left.is(tok::colon) && (Left.isOneOf(TT_DictLiteral, > TT_ObjCMethodExpr))) > return true; > - if (Right.Type == TT_SelectorName) > + if (Right.is(TT_SelectorName)) > return true; > if (Left.is(tok::r_paren) && Line.Type == LT_ObjCProperty) > return true; > if (Left.ClosesTemplateDeclaration) > return true; > - if (Right.Type == TT_RangeBasedForLoopColon || > - Right.Type == TT_OverloadedOperatorLParen || > - Right.Type == TT_OverloadedOperator) > + if (Right.isOneOf(TT_RangeBasedForLoopColon, TT_OverloadedOperatorLParen, > + TT_OverloadedOperator)) > return false; > - if (Left.Type == TT_RangeBasedForLoopColon) > + if (Left.is(TT_RangeBasedForLoopColon)) > return true; > - if (Right.Type == TT_RangeBasedForLoopColon) > + if (Right.is(TT_RangeBasedForLoopColon)) > return false; > - if (Left.Type == TT_PointerOrReference || Left.Type == TT_TemplateCloser || > - Left.Type == TT_UnaryOperator || Left.is(tok::kw_operator)) > + if (Left.isOneOf(TT_PointerOrReference, TT_TemplateCloser, > + TT_UnaryOperator) || > + Left.is(tok::kw_operator)) > return false; > if (Left.is(tok::equal) && Line.Type == LT_VirtualFunctionDecl) > return false; > - if (Left.is(tok::l_paren) && Left.Type == TT_AttributeParen) > + if (Left.is(tok::l_paren) && Left.is(TT_AttributeParen)) > return false; > if (Left.is(tok::l_paren) && Left.Previous && > - (Left.Previous->Type == TT_BinaryOperator || > - Left.Previous->Type == TT_CastRParen || > Left.Previous->is(tok::kw_if))) > + (Left.Previous->isOneOf(TT_BinaryOperator, TT_CastRParen) || > + Left.Previous->is(tok::kw_if))) > return false; > - if (Right.Type == TT_ImplicitStringLiteral) > + if (Right.is(TT_ImplicitStringLiteral)) > return false; > > - if (Right.is(tok::r_paren) || Right.Type == TT_TemplateCloser) > + if (Right.is(tok::r_paren) || Right.is(TT_TemplateCloser)) > return false; > > // We only break before r_brace if there was a corresponding break before > @@ -1975,7 +1966,7 @@ bool TokenAnnotator::canBreakBefore(cons > > // Allow breaking after a trailing annotation, e.g. after a method > // declaration. > - if (Left.Type == TT_TrailingAnnotation) > + if (Left.is(TT_TrailingAnnotation)) > return !Right.isOneOf(tok::l_brace, tok::semi, tok::equal, tok::l_paren, > tok::less, tok::coloncolon); > > @@ -1985,25 +1976,24 @@ bool TokenAnnotator::canBreakBefore(cons > if (Left.is(tok::identifier) && Right.is(tok::string_literal)) > return true; > > - if (Right.is(tok::identifier) && Right.Next && > - Right.Next->Type == TT_DictLiteral) > + if (Right.is(tok::identifier) && Right.Next && > Right.Next->is(TT_DictLiteral)) > return true; > > - if (Left.Type == TT_CtorInitializerComma && > + if (Left.is(TT_CtorInitializerComma) && > Style.BreakConstructorInitializersBeforeComma) > return false; > - if (Right.Type == TT_CtorInitializerComma && > + if (Right.is(TT_CtorInitializerComma) && > Style.BreakConstructorInitializersBeforeComma) > return true; > if (Left.is(tok::greater) && Right.is(tok::greater) && > - Left.Type != TT_TemplateCloser) > + Left.isNot(TT_TemplateCloser)) > return false; > - if (Right.Type == TT_BinaryOperator && > + if (Right.is(TT_BinaryOperator) && > Style.BreakBeforeBinaryOperators != FormatStyle::BOS_None && > (Style.BreakBeforeBinaryOperators == FormatStyle::BOS_All || > Right.getPrecedence() != prec::Assignment)) > return true; > - if (Left.Type == TT_ArrayInitializerLSquare) > + if (Left.is(TT_ArrayInitializerLSquare)) > return true; > if (Right.is(tok::kw_typename) && Left.isNot(tok::kw_const)) > return true; > @@ -2014,7 +2004,7 @@ bool TokenAnnotator::canBreakBefore(cons > return true; > return Left.isOneOf(tok::comma, tok::coloncolon, tok::semi, tok::l_brace, > tok::kw_class, tok::kw_struct) || > - Right.isMemberAccess() || Right.Type == TT_TrailingReturnArrow || > + Right.isMemberAccess() || Right.is(TT_TrailingReturnArrow) || > Right.isOneOf(tok::lessless, tok::colon, tok::l_square, tok::at) || > (Left.is(tok::r_paren) && > Right.isOneOf(tok::identifier, tok::kw_const)) || > > Modified: cfe/trunk/lib/Format/WhitespaceManager.cpp > URL: > http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Format/WhitespaceManager.cpp?rev=222638&r1=222637&r2=222638&view=diff > ============================================================================== > --- cfe/trunk/lib/Format/WhitespaceManager.cpp (original) > +++ cfe/trunk/lib/Format/WhitespaceManager.cpp Sun Nov 23 13:03:25 2014 > @@ -81,7 +81,7 @@ void WhitespaceManager::replaceWhitespac > // FIXME: We still need to take this change in account to properly > // calculate the new length of the comment and to calculate the changes > // for which to do the alignment when aligning comments. > - Tok.Type == TT_LineComment && Newlines > 0 ? tok::comment : > tok::unknown, > + Tok.is(TT_LineComment) && Newlines > 0 ? tok::comment : tok::unknown, > InPPDirective && !Tok.IsFirst)); > } > > > > _______________________________________________ > cfe-commits mailing list > [email protected] > http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits _______________________________________________ cfe-commits mailing list [email protected] http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
