From a98b7b01be4a2d6138c8b9a054e73bea98efa06e Mon Sep 17 00:00:00 2001 From: Daniel Jasper Date: Tue, 25 Nov 2014 10:05:17 +0000 Subject: [PATCH] clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747 --- clang/lib/Format/ContinuationIndenter.cpp | 182 +++++------ clang/lib/Format/Format.cpp | 22 +- clang/lib/Format/FormatToken.h | 51 ++- clang/lib/Format/TokenAnnotator.cpp | 522 +++++++++++++++--------------- clang/lib/Format/WhitespaceManager.cpp | 2 +- clang/unittests/Format/FormatTestJava.cpp | 11 + 6 files changed, 386 insertions(+), 404 deletions(-) diff --git a/clang/lib/Format/ContinuationIndenter.cpp b/clang/lib/Format/ContinuationIndenter.cpp index f4c4522..f8d292b 100644 --- a/clang/lib/Format/ContinuationIndenter.cpp +++ b/clang/lib/Format/ContinuationIndenter.cpp @@ -48,11 +48,11 @@ static bool startsSegmentOfBuilderTypeCall(const FormatToken &Tok) { 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(const LineState &State) { // 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(const LineState &State) { // 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(const LineState &State) { 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(const LineState &State) { 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(const LineState &State) { 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(const LineState &State) { } // 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(const LineState &State) { 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::addTokenToState(LineState &State, bool Newline, 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::addTokenOnCurrentLine(LineState &State, bool DryRun, 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::addTokenOnCurrentLine(LineState &State, bool DryRun, 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::addTokenOnCurrentLine(LineState &State, bool DryRun, 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::addTokenOnCurrentLine(LineState &State, bool DryRun, // 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::addTokenOnNewLine(LineState &State, 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::addTokenOnNewLine(LineState &State, 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::addTokenOnNewLine(LineState &State, 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::addTokenOnNewLine(LineState &State, 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::getNewLineColumn(const LineState &State) { 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::getNewLineColumn(const LineState &State) { } 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::getNewLineColumn(const LineState &State) { 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::moveStateToNextToken(LineState &State, 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::moveStateToNextToken(LineState &State, 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::moveStateToNextToken(LineState &State, // 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::moveStatePastFakeLParens(LineState &State, bool SkipFirstExtraIndent = (Previous && (Previous->opensScope() || Previous->is(tok::kw_return) || Previous->getPrecedence() == prec::Assignment || - Previous->Type == TT_ObjCMethodExpr)); + Previous->is(TT_ObjCMethodExpr))); for (SmallVectorImpl::const_reverse_iterator I = Current.FakeLParens.rbegin(), E = Current.FakeLParens.rend(); @@ -750,13 +738,12 @@ void ContinuationIndenter::moveStatePastFakeLParens(LineState &State, // 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 LineState &State) { 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::moveStatePastScopeOpener(LineState &State, 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::moveStatePastScopeOpener(LineState &State, 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::moveStatePastScopeOpener(LineState &State, 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::moveStatePastScopeCloser(LineState &State) { 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::moveStateToNewBlock(LineState &State) { 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::breakProtrudingToken(const FormatToken &Current, 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::breakProtrudingToken(const FormatToken &Current, } 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::breakProtrudingToken(const FormatToken &Current, // 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::getColumnLimit(const LineState &State) const { 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 diff --git a/clang/lib/Format/Format.cpp b/clang/lib/Format/Format.cpp index 75e3140..8a04571 100644 --- a/clang/lib/Format/Format.cpp +++ b/clang/lib/Format/Format.cpp @@ -618,7 +618,7 @@ public: SmallVectorImpl::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) && @@ -816,7 +815,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) @@ -1658,7 +1657,7 @@ private: } } - if (FormatTok->Type == TT_ImplicitStringLiteral) + if (FormatTok->is(TT_ImplicitStringLiteral)) break; WhitespaceLength += FormatTok->Tok.getLength(); @@ -2030,7 +2029,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() != @@ -2042,11 +2041,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; } diff --git a/clang/lib/Format/FormatToken.h b/clang/lib/Format/FormatToken.h index 053a3b05..732096b 100644 --- a/clang/lib/Format/FormatToken.h +++ b/clang/lib/Format/FormatToken.h @@ -271,26 +271,27 @@ 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 - bool isOneOf(T K1, T K2) const { + template bool isOneOf(A K1, B K2) const { return is(K1) || is(K2); } - - template - bool isOneOf(T K1, T K2, T K3) const { + template + bool isOneOf(A K1, B K2, C K3) const { return is(K1) || is(K2) || is(K3); } - + template + bool isOneOf(A K1, B K2, C K3, D K4) const { + return is(K1) || is(K2) || is(K3) || is(K4); + } + template + bool isOneOf(A K1, B K2, C K3, D K4, E K5) const { + return is(K1) || is(K2) || is(K3) || is(K4) || is(K5); + } template - 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, + bool isOneOf(T K1, T K2, T K3, T K4, T K5, T K6, 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 { @@ -298,11 +299,7 @@ struct FormatToken { is(K8) || is(K9) || is(K10) || is(K11) || is(K12); } - template - bool isNot(T Kind) const { - return Tok.isNot(Kind); - } - bool isNot(IdentifierInfo *II) const { return II != Tok.getIdentifierInfo(); } + template bool isNot(T Kind) const { return !is(Kind); } bool isStringLiteral() const { return tok::isStringLiteral(Tok.getKind()); } @@ -327,20 +324,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 +362,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 +408,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. @@ -550,6 +545,7 @@ struct AdditionalKeywords { kw_extends = &IdentTable.get("extends"); kw_final = &IdentTable.get("final"); kw_implements = &IdentTable.get("implements"); + kw_instanceof = &IdentTable.get("instanceof"); kw_interface = &IdentTable.get("interface"); kw_synchronized = &IdentTable.get("synchronized"); kw_throws = &IdentTable.get("throws"); @@ -575,6 +571,7 @@ struct AdditionalKeywords { IdentifierInfo *kw_extends; IdentifierInfo *kw_final; IdentifierInfo *kw_implements; + IdentifierInfo *kw_instanceof; IdentifierInfo *kw_interface; IdentifierInfo *kw_synchronized; IdentifierInfo *kw_throws; diff --git a/clang/lib/Format/TokenAnnotator.cpp b/clang/lib/Format/TokenAnnotator.cpp index dbf2552..3daea77 100644 --- a/clang/lib/Format/TokenAnnotator.cpp +++ b/clang/lib/Format/TokenAnnotator.cpp @@ -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,89 @@ private: // This should be the condition or increment in a for-loop. Contexts.back().IsExpression = true; } + } - 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.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; + void determineTokenType(FormatToken &Current) { + if (!Current.is(TT_Unknown)) + // The token type is already known. + return; + + // 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 (Current.is(Keywords.kw_instanceof)) { + Current.Type = TT_BinaryOperator; + } else 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. + 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 +892,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 +904,7 @@ private: return true; return (!IsPPKeyword && PreviousNotConst->is(tok::identifier)) || - PreviousNotConst->Type == TT_PointerOrReference || + PreviousNotConst->is(TT_PointerOrReference) || PreviousNotConst->isSimpleTypeSpecifier(); } @@ -916,14 +918,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 +943,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 { @@ -995,12 +996,11 @@ 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) + PrevToken->isOneOf(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 +1043,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 +1053,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 +1063,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 +1095,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 +1126,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 +1176,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 +1218,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 +1241,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 +1294,11 @@ void TokenAnnotator::annotate(AnnotatedLine &Line) { 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 +1308,11 @@ void TokenAnnotator::annotate(AnnotatedLine &Line) { // 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 +1332,7 @@ static bool isFunctionDeclarationName(const FormatToken &Current) { 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 +1356,7 @@ void TokenAnnotator::calculateFormattingInformation(AnnotatedLine &Line) { 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 +1376,7 @@ void TokenAnnotator::calculateFormattingInformation(AnnotatedLine &Line) { 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 +1392,7 @@ void TokenAnnotator::calculateFormattingInformation(AnnotatedLine &Line) { 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 +1416,7 @@ void TokenAnnotator::calculateFormattingInformation(AnnotatedLine &Line) { 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 +1463,7 @@ unsigned TokenAnnotator::splitPenalty(const AnnotatedLine &Line, 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 +1474,20 @@ unsigned TokenAnnotator::splitPenalty(const AnnotatedLine &Line, } 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 +1495,7 @@ unsigned TokenAnnotator::splitPenalty(const AnnotatedLine &Line, } 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 +1503,7 @@ unsigned TokenAnnotator::splitPenalty(const AnnotatedLine &Line, 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 +1513,11 @@ unsigned TokenAnnotator::splitPenalty(const AnnotatedLine &Line, 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 +1535,9 @@ unsigned TokenAnnotator::splitPenalty(const AnnotatedLine &Line, // 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 +1546,7 @@ unsigned TokenAnnotator::splitPenalty(const AnnotatedLine &Line, 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 +1569,7 @@ unsigned TokenAnnotator::splitPenalty(const AnnotatedLine &Line, } 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 +1594,8 @@ bool TokenAnnotator::spaceRequiredBetween(const AnnotatedLine &Line, 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 +1619,48 @@ bool TokenAnnotator::spaceRequiredBetween(const AnnotatedLine &Line, 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 +1676,9 @@ bool TokenAnnotator::spaceRequiredBetween(const AnnotatedLine &Line, } 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 +1689,12 @@ bool TokenAnnotator::spaceRequiredBetween(const AnnotatedLine &Line, 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.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; } @@ -1727,15 +1723,15 @@ bool TokenAnnotator::spaceRequiredBefore(const AnnotatedLine &Line, 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 @@ -1745,31 +1741,30 @@ bool TokenAnnotator::spaceRequiredBefore(const AnnotatedLine &Line, (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) || @@ -1779,27 +1774,26 @@ bool TokenAnnotator::spaceRequiredBefore(const AnnotatedLine &Line, 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); } @@ -1807,7 +1801,7 @@ bool TokenAnnotator::spaceRequiredBefore(const AnnotatedLine &Line, // 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, @@ -1830,7 +1824,7 @@ bool TokenAnnotator::mustBreakBefore(const AnnotatedLine &Line, 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())) { @@ -1846,8 +1840,8 @@ bool TokenAnnotator::mustBreakBefore(const AnnotatedLine &Line, 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; @@ -1872,9 +1866,9 @@ bool TokenAnnotator::mustBreakBefore(const AnnotatedLine &Line, 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; } @@ -1885,7 +1879,7 @@ bool TokenAnnotator::mustBreakBefore(const AnnotatedLine &Line, 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 && @@ -1913,10 +1907,10 @@ bool TokenAnnotator::canBreakBefore(const AnnotatedLine &Line, 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 @@ -1927,47 +1921,46 @@ bool TokenAnnotator::canBreakBefore(const AnnotatedLine &Line, 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 @@ -1977,7 +1970,7 @@ bool TokenAnnotator::canBreakBefore(const AnnotatedLine &Line, // 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); @@ -1987,25 +1980,24 @@ bool TokenAnnotator::canBreakBefore(const AnnotatedLine &Line, 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; @@ -2016,7 +2008,7 @@ bool TokenAnnotator::canBreakBefore(const AnnotatedLine &Line, 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)) || diff --git a/clang/lib/Format/WhitespaceManager.cpp b/clang/lib/Format/WhitespaceManager.cpp index 47b94de..a2f5991 100644 --- a/clang/lib/Format/WhitespaceManager.cpp +++ b/clang/lib/Format/WhitespaceManager.cpp @@ -81,7 +81,7 @@ void WhitespaceManager::replaceWhitespaceInToken( // 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)); } diff --git a/clang/unittests/Format/FormatTestJava.cpp b/clang/unittests/Format/FormatTestJava.cpp index ba91f16..5a45b80 100644 --- a/clang/unittests/Format/FormatTestJava.cpp +++ b/clang/unittests/Format/FormatTestJava.cpp @@ -54,6 +54,17 @@ TEST_F(FormatTestJava, NoAlternativeOperatorNames) { verifyFormat("someObject.and();"); } +TEST_F(FormatTestJava, FormatsInstanceOfLikeOperators) { + FormatStyle Style = getStyleWithColumns(50); + verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + " instanceof bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;", + Style); + Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; + verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaa instanceof\n" + " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;", + Style); +} + TEST_F(FormatTestJava, ClassDeclarations) { verifyFormat("public class SomeClass {\n" " private int a;\n" -- 2.7.4