maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Reverting r222638; it broke the MSVC build bots because Visual Studio 2012 does not support variadic templates. Also reverting r222641 because it was relying on 222638. 

llvm-svn: 222656
This commit is contained in:
Aaron Ballman 2014-11-24 15:42:34 +00:00
parent ef43413593
commit 484ee9b404
6 changed files with 413 additions and 382 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

182
clang/lib/Format/ContinuationIndenter.cpp
View File

@ -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.is(TT_CtorInitializerComma) &&
if (Current.Type == TT_CtorInitializerComma &&
Style.BreakConstructorInitializersBeforeComma)
return true;
return Previous.is(tok::comma) && !Current.isTrailingComment() &&
(Previous.isNot(TT_CtorInitializerComma) ||
(Previous.Type != 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.isNot(TT_DictLiteral) && Previous.BlockKind == BK_BracedInit &&
Previous.Type != 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.is(TT_FunctionDeclarationName) &&
if (Current.Type == 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.is(TT_InlineASMColon))
if (Current.MustBreakBefore || Current.Type == 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.is(TT_ConditionalExpr) && Previous.isNot(tok::question)))) ||
(Current.is(tok::question) || (Current.Type == TT_ConditionalExpr &&
Previous.isNot(tok::question)))) ||
(!Style.BreakBeforeTernaryOperators &&
(Previous.is(tok::question) || Previous.is(TT_ConditionalExpr)))) &&
(Previous.is(tok::question) || Previous.Type == 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.isOneOf(TT_InlineASMColon, TT_ConditionalExpr) &&
nextIsMultilineString(State))
Previous.Type != TT_InlineASMColon &&
Previous.Type != TT_ConditionalExpr && nextIsMultilineString(State))
return true;
if (((Previous.is(TT_DictLiteral) && Previous.is(tok::l_brace)) ||
Previous.is(TT_ArrayInitializerLSquare)) &&
if (((Previous.Type == TT_DictLiteral && Previous.is(tok::l_brace)) ||
Previous.Type == TT_ArrayInitializerLSquare) &&
Style.ColumnLimit > 0 &&
getLengthToMatchingParen(Previous) + State.Column > getColumnLimit(State))
return true;
if (Current.is(TT_CtorInitializerColon) &&
if (Current.Type == TT_CtorInitializerColon &&
((Style.AllowShortFunctionsOnASingleLine != FormatStyle::SFS_All) ||
Style.BreakConstructorInitializersBeforeComma || Style.ColumnLimit != 0))
return true;
@ -184,11 +184,12 @@ bool ContinuationIndenter::mustBreak(const LineState &State) {
bool IsComparison = (Previous.getPrecedence() == prec::Relational ||
Previous.getPrecedence() == prec::Equality) &&
Previous.Previous &&
Previous.Previous->isNot(TT_BinaryOperator); // For >>.
Previous.Previous->Type != TT_BinaryOperator; // For >>.
bool LHSIsBinaryExpr =
Previous.Previous && Previous.Previous->EndsBinaryExpression;
if (Previous.is(TT_BinaryOperator) && (!IsComparison || LHSIsBinaryExpr) &&
Current.isNot(TT_BinaryOperator) && // For >>.
if (Previous.Type == TT_BinaryOperator &&
(!IsComparison || LHSIsBinaryExpr) &&
Current.Type != TT_BinaryOperator && // For >>.
!Current.isTrailingComment() && !Previous.is(tok::lessless) &&
Previous.getPrecedence() != prec::Assignment &&
State.Stack.back().BreakBeforeParameter)
@ -196,12 +197,13 @@ bool ContinuationIndenter::mustBreak(const LineState &State) {
}
// Same as above, but for the first "<<" operator.
if (Current.is(tok::lessless) && Current.isNot(TT_OverloadedOperator) &&
if (Current.is(tok::lessless) && Current.Type != TT_OverloadedOperator &&
State.Stack.back().BreakBeforeParameter &&
State.Stack.back().FirstLessLess == 0)
return true;
if (Current.is(TT_SelectorName) && State.Stack.back().ObjCSelectorNameFound &&
if (Current.Type == TT_SelectorName &&
State.Stack.back().ObjCSelectorNameFound &&
State.Stack.back().BreakBeforeParameter)
return true;
if (Previous.ClosesTemplateDeclaration && Current.NestingLevel == 0 &&
@ -209,7 +211,8 @@ bool ContinuationIndenter::mustBreak(const LineState &State) {
return true;
// If the return type spans multiple lines, wrap before the function name.
if (Current.isOneOf(TT_FunctionDeclarationName ,tok::kw_operator) &&
if ((Current.Type == TT_FunctionDeclarationName ||
Current.is(tok::kw_operator)) &&
State.Stack.back().BreakBeforeParameter)
return true;
@ -235,7 +238,7 @@ unsigned ContinuationIndenter::addTokenToState(LineState &State, bool Newline,
const FormatToken &Current = *State.NextToken;
assert(!State.Stack.empty());
if ((Current.is(TT_ImplicitStringLiteral) &&
if ((Current.Type == TT_ImplicitStringLiteral &&
(Current.Previous->Tok.getIdentifierInfo() == nullptr ||
Current.Previous->Tok.getIdentifierInfo()->getPPKeywordID() ==
tok::pp_not_keyword))) {
@ -284,7 +287,7 @@ void ContinuationIndenter::addTokenOnCurrentLine(LineState &State, bool DryRun,
Whitespaces.replaceWhitespace(Current, /*Newlines=*/0, /*IndentLevel=*/0,
Spaces, State.Column + Spaces);
if (Current.is(TT_SelectorName) &&
if (Current.Type == TT_SelectorName &&
!State.Stack.back().ObjCSelectorNameFound) {
if (Current.LongestObjCSelectorName == 0)
State.Stack.back().AlignColons = false;
@ -296,9 +299,9 @@ void ContinuationIndenter::addTokenOnCurrentLine(LineState &State, bool DryRun,
State.Stack.back().ColonPos = State.Column + Spaces + Current.ColumnWidth;
}
if (Style.AlignAfterOpenBracket && Previous.opensScope() &&
Previous.isNot(TT_ObjCMethodExpr) &&
(Current.isNot(TT_LineComment) || Previous.BlockKind == BK_BracedInit))
if (Style.AlignAfterOpenBracket &&
Previous.opensScope() && Previous.Type != TT_ObjCMethodExpr &&
(Current.Type != 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;
@ -325,10 +328,11 @@ 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.is(TT_ObjCMethodExpr))))
(Previous.is(tok::colon) && Previous.Type == TT_ObjCMethodExpr)))
State.Stack.back().LastSpace = State.Column;
else if ((Previous.isOneOf(TT_BinaryOperator, TT_ConditionalExpr,
TT_CtorInitializerColon)) &&
else if ((Previous.Type == TT_BinaryOperator ||
Previous.Type == TT_ConditionalExpr ||
Previous.Type == TT_CtorInitializerColon) &&
((Previous.getPrecedence() != prec::Assignment &&
(Previous.isNot(tok::lessless) || Previous.OperatorIndex != 0 ||
!Previous.LastOperator)) ||
@ -337,7 +341,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.is(TT_InheritanceColon)) {
else if (Previous.Type == TT_InheritanceColon) {
State.Stack.back().Indent = State.Column;
State.Stack.back().LastSpace = State.Column;
} else if (Previous.opensScope()) {
@ -391,7 +395,7 @@ unsigned ContinuationIndenter::addTokenOnNewLine(LineState &State,
if (NextNonComment->isMemberAccess()) {
if (State.Stack.back().CallContinuation == 0)
State.Stack.back().CallContinuation = State.Column;
} else if (NextNonComment->is(TT_SelectorName)) {
} else if (NextNonComment->Type == TT_SelectorName) {
if (!State.Stack.back().ObjCSelectorNameFound) {
if (NextNonComment->LongestObjCSelectorName == 0) {
State.Stack.back().AlignColons = false;
@ -404,7 +408,8 @@ unsigned ContinuationIndenter::addTokenOnNewLine(LineState &State,
State.Stack.back().ColonPos = State.Column + NextNonComment->ColumnWidth;
}
} else if (PreviousNonComment && PreviousNonComment->is(tok::colon) &&
PreviousNonComment->isOneOf(TT_ObjCMethodExpr, TT_DictLiteral)) {
(PreviousNonComment->Type == TT_ObjCMethodExpr ||
PreviousNonComment->Type == 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.:
@ -422,9 +427,10 @@ unsigned ContinuationIndenter::addTokenOnNewLine(LineState &State,
if ((Previous.isOneOf(tok::comma, tok::semi) &&
!State.Stack.back().AvoidBinPacking) ||
Previous.is(TT_BinaryOperator))
Previous.Type == TT_BinaryOperator)
State.Stack.back().BreakBeforeParameter = false;
if (Previous.isOneOf(TT_TemplateCloser, TT_JavaAnnotation) &&
if ((Previous.Type == TT_TemplateCloser ||
Previous.Type == TT_JavaAnnotation) &&
Current.NestingLevel == 0)
State.Stack.back().BreakBeforeParameter = false;
if (NextNonComment->is(tok::question) ||
@ -457,27 +463,30 @@ unsigned ContinuationIndenter::addTokenOnNewLine(LineState &State,
if (PreviousNonComment &&
!PreviousNonComment->isOneOf(tok::comma, tok::semi) &&
(PreviousNonComment->isNot(TT_TemplateCloser) ||
(PreviousNonComment->Type != TT_TemplateCloser ||
Current.NestingLevel != 0) &&
!PreviousNonComment->isOneOf(TT_BinaryOperator, TT_JavaAnnotation,
TT_LeadingJavaAnnotation) &&
Current.isNot(TT_BinaryOperator) && !PreviousNonComment->opensScope())
PreviousNonComment->Type != TT_BinaryOperator &&
PreviousNonComment->Type != TT_JavaAnnotation &&
PreviousNonComment->Type != TT_LeadingJavaAnnotation &&
Current.Type != 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->isOneOf(tok::l_brace, TT_ArrayInitializerLSquare)))
(PreviousNonComment->is(tok::l_brace) ||
PreviousNonComment->Type == 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, TT_BinaryOperator) ||
if (!(Previous.isOneOf(tok::l_paren, tok::l_brace) ||
Previous.Type == TT_BinaryOperator) ||
(!Style.AllowAllParametersOfDeclarationOnNextLine &&
State.Line->MustBeDeclaration) ||
Previous.is(TT_DictLiteral))
Previous.Type == TT_DictLiteral)
State.Stack.back().BreakBeforeParameter = true;
}
@ -519,7 +528,7 @@ unsigned ContinuationIndenter::getNewLineColumn(const LineState &State) {
return State.FirstIndent;
}
if (Current.is(tok::identifier) && Current.Next &&
Current.Next->is(TT_DictLiteral))
Current.Next->Type == TT_DictLiteral)
return State.Stack.back().Indent;
if (NextNonComment->isStringLiteral() && State.StartOfStringLiteral != 0)
return State.StartOfStringLiteral;
@ -535,19 +544,21 @@ unsigned ContinuationIndenter::getNewLineColumn(const LineState &State) {
}
if (State.Stack.back().QuestionColumn != 0 &&
((NextNonComment->is(tok::colon) &&
NextNonComment->is(TT_ConditionalExpr)) ||
Previous.is(TT_ConditionalExpr)))
NextNonComment->Type == TT_ConditionalExpr) ||
Previous.Type == 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->isOneOf(TT_AttributeParen, TT_JavaAnnotation,
TT_LeadingJavaAnnotation))) ||
PreviousNonComment->Type == TT_AttributeParen ||
PreviousNonComment->Type == TT_JavaAnnotation ||
PreviousNonComment->Type == TT_LeadingJavaAnnotation)) ||
(!Style.IndentWrappedFunctionNames &&
NextNonComment->isOneOf(tok::kw_operator, TT_FunctionDeclarationName)))
(NextNonComment->is(tok::kw_operator) ||
NextNonComment->Type == TT_FunctionDeclarationName)))
return std::max(State.Stack.back().LastSpace, State.Stack.back().Indent);
if (NextNonComment->is(TT_SelectorName)) {
if (NextNonComment->Type == TT_SelectorName) {
if (!State.Stack.back().ObjCSelectorNameFound) {
if (NextNonComment->LongestObjCSelectorName == 0) {
return State.Stack.back().Indent;
@ -564,22 +575,23 @@ unsigned ContinuationIndenter::getNewLineColumn(const LineState &State) {
return State.Stack.back().Indent;
}
}
if (NextNonComment->is(TT_ArraySubscriptLSquare)) {
if (NextNonComment->Type == TT_ArraySubscriptLSquare) {
if (State.Stack.back().StartOfArraySubscripts != 0)
return State.Stack.back().StartOfArraySubscripts;
else
return ContinuationIndent;
}
if (NextNonComment->is(TT_StartOfName) ||
if (NextNonComment->Type == TT_StartOfName ||
Previous.isOneOf(tok::coloncolon, tok::equal)) {
return ContinuationIndent;
}
if (PreviousNonComment && PreviousNonComment->is(tok::colon) &&
PreviousNonComment->isOneOf(TT_ObjCMethodExpr, TT_DictLiteral))
(PreviousNonComment->Type == TT_ObjCMethodExpr ||
PreviousNonComment->Type == TT_DictLiteral))
return ContinuationIndent;
if (NextNonComment->is(TT_CtorInitializerColon))
if (NextNonComment->Type == TT_CtorInitializerColon)
return State.FirstIndent + Style.ConstructorInitializerIndentWidth;
if (NextNonComment->is(TT_CtorInitializerComma))
if (NextNonComment->Type == TT_CtorInitializerComma)
return State.Stack.back().Indent;
if (Previous.is(tok::r_paren) && !Current.isBinaryOperator() &&
!Current.isOneOf(tok::colon, tok::comment))
@ -597,18 +609,18 @@ unsigned ContinuationIndenter::moveStateToNextToken(LineState &State,
assert(State.Stack.size());
const FormatToken &Current = *State.NextToken;
if (Current.is(TT_InheritanceColon))
if (Current.Type == TT_InheritanceColon)
State.Stack.back().AvoidBinPacking = true;
if (Current.is(tok::lessless) && Current.isNot(TT_OverloadedOperator)) {
if (Current.is(tok::lessless) && Current.Type != TT_OverloadedOperator) {
if (State.Stack.back().FirstLessLess == 0)
State.Stack.back().FirstLessLess = State.Column;
else
State.Stack.back().LastOperatorWrapped = Newline;
}
if ((Current.is(TT_BinaryOperator) && Current.isNot(tok::lessless)) ||
Current.is(TT_ConditionalExpr))
if ((Current.Type == TT_BinaryOperator && Current.isNot(tok::lessless)) ||
Current.Type == TT_ConditionalExpr)
State.Stack.back().LastOperatorWrapped = Newline;
if (Current.is(TT_ArraySubscriptLSquare) &&
if (Current.Type == TT_ArraySubscriptLSquare &&
State.Stack.back().StartOfArraySubscripts == 0)
State.Stack.back().StartOfArraySubscripts = State.Column;
if ((Current.is(tok::question) && Style.BreakBeforeTernaryOperators) ||
@ -622,9 +634,9 @@ unsigned ContinuationIndenter::moveStateToNextToken(LineState &State,
if (Current.isMemberAccess())
State.Stack.back().StartOfFunctionCall =
Current.LastOperator ? 0 : State.Column + Current.ColumnWidth;
if (Current.is(TT_SelectorName))
if (Current.Type == TT_SelectorName)
State.Stack.back().ObjCSelectorNameFound = true;
if (Current.is(TT_CtorInitializerColon)) {
if (Current.Type == TT_CtorInitializerColon) {
// Indent 2 from the column, so:
// SomeClass::SomeClass()
// : First(...), ...
@ -640,7 +652,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.is(TT_ObjCMethodSpecifier))
if (Current.Type == TT_ObjCMethodSpecifier)
State.Stack.back().Indent += Style.ContinuationIndentWidth;
// Insert scopes created by fake parenthesis.
@ -713,7 +725,7 @@ void ContinuationIndenter::moveStatePastFakeLParens(LineState &State,
bool SkipFirstExtraIndent =
(Previous && (Previous->opensScope() || Previous->is(tok::kw_return) ||
Previous->getPrecedence() == prec::Assignment ||
Previous->is(TT_ObjCMethodExpr)));
Previous->Type == TT_ObjCMethodExpr));
for (SmallVectorImpl<prec::Level>::const_reverse_iterator
I = Current.FakeLParens.rbegin(),
E = Current.FakeLParens.rend();
@ -738,12 +750,13 @@ 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->isOneOf(TT_BinaryOperator, TT_ConditionalExpr) &&
(Previous->Type == TT_BinaryOperator ||
Previous->Type == TT_ConditionalExpr) &&
Previous->getPrecedence() != prec::Relational) {
bool BreakBeforeOperator = Previous->is(tok::lessless) ||
(Previous->is(TT_BinaryOperator) &&
(Previous->Type == TT_BinaryOperator &&
Style.BreakBeforeBinaryOperators) ||
(Previous->is(TT_ConditionalExpr) &&
(Previous->Type == TT_ConditionalExpr &&
Style.BreakBeforeTernaryOperators);
if ((!Newline && !BreakBeforeOperator) ||
(!State.Stack.back().LastOperatorWrapped && BreakBeforeOperator))
@ -816,7 +829,8 @@ static bool fakeRParenSpecialCase(const LineState &State) {
return !State.Stack.back().HasMultipleNestedBlocks &&
Left->isOneOf(tok::l_brace, tok::l_square) &&
(Left->BlockKind == BK_Block ||
Left->isOneOf(TT_ArrayInitializerLSquare, TT_DictLiteral));
Left->Type == TT_ArrayInitializerLSquare ||
Left->Type == TT_DictLiteral);
}
void ContinuationIndenter::moveStatePastFakeRParens(LineState &State) {
@ -843,7 +857,7 @@ void ContinuationIndenter::moveStatePastScopeOpener(LineState &State,
unsigned NewIndentLevel = State.Stack.back().IndentLevel;
bool AvoidBinPacking;
bool BreakBeforeParameter = false;
if (Current.isOneOf(tok::l_brace, TT_ArrayInitializerLSquare)) {
if (Current.is(tok::l_brace) || Current.Type == TT_ArrayInitializerLSquare) {
if (fakeRParenSpecialCase(State))
consumeRParens(State, *Current.MatchingParen);
@ -857,10 +871,12 @@ void ContinuationIndenter::moveStatePastScopeOpener(LineState &State,
NewIndent = std::min(State.Column + 1, NewIndent);
}
const FormatToken *NextNoComment = Current.getNextNonComment();
AvoidBinPacking =
Current.isOneOf(TT_ArrayInitializerLSquare, TT_DictLiteral) ||
Style.Language == FormatStyle::LK_Proto || !Style.BinPackParameters ||
(NextNoComment && NextNoComment->is(TT_DesignatedInitializerPeriod));
AvoidBinPacking = Current.Type == TT_ArrayInitializerLSquare ||
Current.Type == TT_DictLiteral ||
Style.Language == FormatStyle::LK_Proto ||
!Style.BinPackParameters ||
(NextNoComment &&
NextNoComment->Type == TT_DesignatedInitializerPeriod);
} else {
NewIndent = Style.ContinuationIndentWidth +
std::max(State.Stack.back().LastSpace,
@ -874,13 +890,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.is(TT_ObjCMethodExpr) && Style.ColumnLimit != 0 &&
if (Current.Type == TT_ObjCMethodExpr && Style.ColumnLimit != 0 &&
getLengthToMatchingParen(Current) + State.Column >
getColumnLimit(State))
BreakBeforeParameter = true;
}
bool NoLineBreak = State.Stack.back().NoLineBreak ||
(Current.is(TT_TemplateOpener) &&
(Current.Type == TT_TemplateOpener &&
State.Stack.back().ContainsUnwrappedBuilder);
State.Stack.push_back(ParenState(NewIndent, NewIndentLevel,
State.Stack.back().LastSpace,
@ -899,7 +915,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->is(TT_TemplateCloser)))
State.NextToken->Type == TT_TemplateCloser))
State.Stack.pop_back();
if (Current.is(tok::r_square)) {
@ -917,10 +933,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->is(TT_ObjCBlockLBrace)
? Style.ObjCBlockIndentWidth
: Style.IndentWidth);
unsigned NewIndent = State.Stack.back().LastSpace +
(State.NextToken->Type == TT_ObjCBlockLBrace
? Style.ObjCBlockIndentWidth
: Style.IndentWidth);
State.Stack.push_back(ParenState(
NewIndent, /*NewIndentLevel=*/State.Stack.back().IndentLevel + 1,
State.Stack.back().LastSpace, /*AvoidBinPacking=*/true,
@ -967,11 +983,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.isNot(TT_BlockComment) && Current.IsMultiline)
if (Current.Type != TT_BlockComment && Current.IsMultiline)
return addMultilineToken(Current, State);
// Don't break implicit string literals or import statements.
if (Current.is(TT_ImplicitStringLiteral) ||
if (Current.Type == TT_ImplicitStringLiteral ||
State.Line->Type == LT_ImportStatement)
return 0;
@ -1021,15 +1037,15 @@ unsigned ContinuationIndenter::breakProtrudingToken(const FormatToken &Current,
} else {
return 0;
}
} else if (Current.is(TT_BlockComment) && Current.isTrailingComment()) {
} else if (Current.Type == 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.is(TT_LineComment) &&
} else if (Current.Type == TT_LineComment &&
(Current.Previous == nullptr ||
Current.Previous->isNot(TT_ImplicitStringLiteral))) {
Current.Previous->Type != TT_ImplicitStringLiteral)) {
if (CommentPragmasRegex.match(Current.TokenText.substr(2)))
return 0;
Token.reset(new BreakableLineComment(Current, State.Line->Level,
@ -1103,7 +1119,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.isNot(TT_LineComment)) {
if (Current.Type != TT_LineComment) {
for (unsigned i = 0, e = State.Stack.size(); i != e; ++i)
State.Stack[i].BreakBeforeParameter = true;
}
@ -1123,7 +1139,7 @@ unsigned ContinuationIndenter::getColumnLimit(const LineState &State) const {
bool ContinuationIndenter::nextIsMultilineString(const LineState &State) {
const FormatToken &Current = *State.NextToken;
if (!Current.isStringLiteral() || Current.is(TT_ImplicitStringLiteral))
if (!Current.isStringLiteral() || Current.Type == TT_ImplicitStringLiteral)
return false;
// We never consider raw string literals "multiline" for the purpose of
// AlwaysBreakBeforeMultilineStrings implementation as they are special-cased

22
clang/lib/Format/Format.cpp
View File

@ -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->is(TT_LineComment))
if (TheLine->Last->Type == 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->is(TT_FunctionLBrace) &&
if (TheLine->Last->Type == 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->is(TT_FunctionLBrace) &&
if (I[1]->First->Type == TT_FunctionLBrace &&
Style.BreakBeforeBraces != FormatStyle::BS_Attach) {
// Check for Limit <= 2 to account for the " {".
if (Limit <= 2 || (Style.ColumnLimit == 0 && containsMustBreak(TheLine)))
@ -725,7 +725,8 @@ 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, TT_LineComment))
tok::kw_while) ||
I[1]->First->Type == TT_LineComment)
return 0;
// Only inline simple if's (no nested if or else).
if (I + 2 != E && Line.First->is(tok::kw_if) &&
@ -815,7 +816,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->is(TT_LineComment))
if (I[1]->Last->Type == TT_LineComment)
return 0;
do {
if (Tok->is(tok::l_brace) && Tok->BlockKind != BK_BracedInit)
@ -1657,7 +1658,7 @@ private:
}
}
if (FormatTok->is(TT_ImplicitStringLiteral))
if (FormatTok->Type == TT_ImplicitStringLiteral)
break;
WhitespaceLength += FormatTok->Tok.getLength();
@ -2029,7 +2030,7 @@ private:
continue;
FormatToken *Tok = AnnotatedLines[i]->First->Next;
while (Tok->Next) {
if (Tok->is(TT_PointerOrReference)) {
if (Tok->Type == TT_PointerOrReference) {
bool SpacesBefore =
Tok->WhitespaceRange.getBegin() != Tok->WhitespaceRange.getEnd();
bool SpacesAfter = Tok->Next->WhitespaceRange.getBegin() !=
@ -2041,10 +2042,11 @@ private:
}
if (Tok->WhitespaceRange.getBegin() == Tok->WhitespaceRange.getEnd()) {
if (Tok->is(tok::coloncolon) && Tok->Previous->is(TT_TemplateOpener))
if (Tok->is(tok::coloncolon) &&
Tok->Previous->Type == TT_TemplateOpener)
HasCpp03IncompatibleFormat = true;
if (Tok->is(TT_TemplateCloser) &&
Tok->Previous->is(TT_TemplateCloser))
if (Tok->Type == TT_TemplateCloser &&
Tok->Previous->Type == TT_TemplateCloser)
HasCpp03IncompatibleFormat = true;
}

54
clang/lib/Format/FormatToken.h
View File

@ -271,22 +271,38 @@ 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();
}
bool isOneOf() const { return false; }
template <typename T, typename... L> bool isOneOf(T Type, L... args) const {
return is(Type) || isOneOf(args...);
}
// This overload increases performance by ~3%.
// FIXME: Re-evaluate this.
template <typename T> bool isOneOf(T K1, T K2) const {
template <typename T>
bool isOneOf(T K1, T K2) const {
return is(K1) || is(K2);
}
template <typename T> bool isNot(T Kind) const { return !is(Kind); }
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(); }
bool isStringLiteral() const { return tok::isStringLiteral(Tok.getKind()); }
@ -311,19 +327,20 @@ 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,
TT_TemplateOpener);
return isOneOf(tok::l_paren, tok::l_brace, tok::l_square) ||
Type == 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,
TT_TemplateCloser);
return isOneOf(tok::r_paren, tok::r_brace, tok::r_square) ||
Type == 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) &&
!isOneOf(TT_DesignatedInitializerPeriod, TT_TrailingReturnArrow);
Type != TT_DesignatedInitializerPeriod &&
Type != TT_TrailingReturnArrow;
}
bool isUnaryOperator() const {
@ -349,7 +366,7 @@ struct FormatToken {
bool isTrailingComment() const {
return is(tok::comment) &&
(is(TT_LineComment) || !Next || Next->NewlinesBefore > 0);
(Type == TT_LineComment || !Next || Next->NewlinesBefore > 0);
}
/// \brief Returns \c true if this is a keyword that can be used
@ -395,9 +412,10 @@ 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 is(TT_ArrayInitializerLSquare) ||
(is(tok::l_brace) && (BlockKind == BK_Block || is(TT_DictLiteral) ||
!Style.Cpp11BracedListStyle));
return Type == TT_ArrayInitializerLSquare ||
(is(tok::l_brace) &&
(BlockKind == BK_Block || Type == TT_DictLiteral ||
!Style.Cpp11BracedListStyle));
}
/// \brief Same as opensBlockTypeList, but for the closing token.
@ -532,7 +550,6 @@ 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");
@ -558,7 +575,6 @@ struct AdditionalKeywords {
IdentifierInfo *kw_extends;
IdentifierInfo *kw_final;
IdentifierInfo *kw_implements;
IdentifierInfo *kw_instanceof;
IdentifierInfo *kw_interface;
IdentifierInfo *kw_synchronized;
IdentifierInfo *kw_throws;

524
clang/lib/Format/TokenAnnotator.cpp
View File

File diff suppressed because it is too large Load Diff

2
clang/lib/Format/WhitespaceManager.cpp
View File

@ -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.is(TT_LineComment) && Newlines > 0 ? tok::comment : tok::unknown,
Tok.Type == TT_LineComment && Newlines > 0 ? tok::comment : tok::unknown,
InPPDirective && !Tok.IsFirst));
}

11
clang/unittests/Format/FormatTestJava.cpp
View File

@ -54,17 +54,6 @@ 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"