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