r222638 - clang-format: Refactoring.
Aaron Ballman
aaron at aaronballman.com
Mon Nov 24 07:43:46 PST 2014
I have reverted this commit, and r222641 (which relied on this change)
in r222656. Hopefully it doesn't cause too many problems for you!
~Aaron
On Mon, Nov 24, 2014 at 7:17 AM, NAKAMURA Takumi <geek4civic at gmail.com> wrote:
> 2014-11-24 4:03 GMT+09:00 Daniel Jasper <djasper at google.com>:
>> 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
>> cfe-commits at cs.uiuc.edu
>> http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
More information about the cfe-commits
mailing list