r222638 - clang-format: Refactoring.
Daniel Jasper
djasper at google.com
Tue Nov 25 01:48:56 PST 2014
Ah, no problem at all, sorry for causing the trouble in the first place.
Will create a version without variadic templates.
On Mon, Nov 24, 2014 at 4:43 PM, Aaron Ballman <aaron at aaronballman.com>
wrote:
> 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
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/cfe-commits/attachments/20141125/8f2c5e8a/attachment.html>
More information about the cfe-commits
mailing list