Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/ContinuationIndenter_8cpp_source.html below:

clang: lib/Format/ContinuationIndenter.cpp Source File

->isOneOf(tok::kw_return, TT_RequiresClause));

MatchingStackIndex = Stack.size() - 1;

(MatchingStackIndex >= 0 && Stack[MatchingStackIndex].Tok != LBrace)

--MatchingStackIndex;

MatchingStackIndex >= 0 ? &Stack[MatchingStackIndex] :

;

(; End->Next; End = End->Next) {

(End->Next->CanBreakBefore)

(!End->Next->closesScope())

(End->Next->MatchingParen &&

End->Next->MatchingParen->isOneOf(

tok::l_brace, TT_ArrayInitializerLSquare, tok::less)) {

*State = FindParenState(End->Next->MatchingParen);

(State && State->BreakBeforeClosingBrace)

HasTwoOperands =

.OperatorIndex == 0 && !

.NextOperator;

.

(TT_BinaryOperator) && !HasTwoOperands &&

(LessTok.

(tok::less))

(TokenText.size() < 5

|| !TokenText.starts_with(

) || !TokenText.ends_with(

)) {

LParenPos = TokenText.substr(0, 19).find_first_of(

);

(LParenPos == StringRef::npos)

StringRef Delimiter = TokenText.substr(2, LParenPos - 2);

RParenPos = TokenText.size() - Delimiter.size() - 2;

(TokenText[RParenPos] !=

)

(!TokenText.substr(RParenPos + 1).starts_with(Delimiter))

StringRef(Format.CanonicalDelimiter);

std::optional<FormatStyle> LanguageStyle =

(!LanguageStyle) {

RawStringFormat.Language, &PredefinedStyle)) {

PredefinedStyle.

= RawStringFormat.Language;

LanguageStyle = PredefinedStyle;

(StringRef Delimiter : RawStringFormat.Delimiters)

(StringRef EnclosingFunction : RawStringFormat.EnclosingFunctions)

std::optional<FormatStyle>

std::optional<FormatStyle>

StringRef EnclosingFunction)

{

BinPackInconclusiveFunctions)

: Style(Style), Keywords(Keywords), SourceMgr(SourceMgr),

Whitespaces(Whitespaces), Encoding(Encoding),

BinPackInconclusiveFunctions(BinPackInconclusiveFunctions),

CommentPragmasRegex(Style.CommentPragmas), RawStringFormats(Style) {}

FirstStartColumn,

State.FirstIndent = FirstIndent;

(FirstStartColumn &&

->First->NewlinesBefore == 0)

State.Column = FirstStartColumn;

State.Column = FirstIndent;

State.NextToken =

->First;

State.Stack.push_back(

(

, FirstIndent, FirstIndent,

State.NoContinuation =

;

State.StartOfStringLiteral = 0;

State.NoLineBreak =

;

State.StartOfLineLevel = 0;

State.LowestLevelOnLine = 0;

State.IgnoreStackForComparison =

;

&CurrentState = State.Stack.back();

CurrentState.AvoidBinPacking =

;

CurrentState.BreakBeforeParameter =

;

CurrentState.AlignColons =

;

moveStateToNextToken(State, DryRun,

);

&CurrentState = State.Stack.back();

assert(&

== Current.Previous);

(!Current.CanBreakBefore && !(CurrentState.BreakBeforeClosingBrace &&

Current.closesBlockOrBlockTypeList(Style))) {

(!Current.MustBreakBefore &&

.is(tok::l_brace) &&

.Previous->isOneOf(tok::l_brace, tok::l_paren, tok::comma)) {

State.LowestLevelOnLine < State.StartOfLineLevel &&

State.LowestLevelOnLine < Current.NestingLevel) {

(Current.isMemberAccess() && CurrentState.ContainsUnwrappedBuilder)

(

.is(tok::l_brace) && State.Stack.size() > 1 &&

State.Stack[State.Stack.size() - 2].NestedBlockInlined &&

State.Stack[State.Stack.size() - 2].HasMultipleNestedBlocks &&

(Current.is(TT_FunctionDeclarationName)) {

assert(State.Column >= State.FirstIndent);

(State.Column - State.FirstIndent < 6)

Current.is(tok::r_paren)) {

CurrentState.BreakBeforeClosingParen;

(Current.is(tok::r_brace) && Current.MatchingParen &&

Current.isBlockIndentedInitRBrace(Style)) {

CurrentState.BreakBeforeClosingBrace;

(!Current.isOneOf(TT_BinaryOperator, tok::comma) &&

Current.isNot(TT_LambdaLBrace)) &&

CurrentState.NoLineBreakInOperand) {

(Current.is(TT_ConditionalExpr) &&

.is(tok::r_paren) &&

.MatchingParen->Previous->MatchingParen &&

.MatchingParen->Previous->MatchingParen->is(TT_LambdaLBrace)) {

assert(

.MatchingParen->Previous->is(tok::r_brace));

!State.NoLineBreak && !CurrentState.NoLineBreak;

&CurrentState = State.Stack.back();

Current.is(TT_LambdaLBrace) &&

.isNot(TT_LineComment)) {

(Current.MustBreakBefore ||

(Current.is(TT_InlineASMColon) &&

(CurrentState.BreakBeforeClosingBrace &&

(Current.closesBlockOrBlockTypeList(Style) ||

(Current.is(tok::r_brace) &&

Current.isBlockIndentedInitRBrace(Style)))) {

(CurrentState.BreakBeforeClosingParen && Current.is(tok::r_paren))

Current.ObjCSelectorNameParts > 1 &&

Current.startsSequence(TT_SelectorName, tok::colon, tok::caret)) {

(CurrentState.IsCSharpGenericTypeConstraint &&

.isNot(TT_CSharpGenericTypeConstraintComma)) {

(

.is(TT_TemplateCloser) && Current.is(TT_StartOfName) &&

State.Line->First->isNot(TT_AttributeSquare) && Style.

() &&

.is(TT_ConditionalExpr))) &&

CurrentState.BreakBeforeParameter && !Current.isTrailingComment() &&

!Current.isOneOf(tok::r_paren, tok::r_brace)) {

(CurrentState.IsChainedConditional &&

Current.is(tok::colon)) ||

(

.is(TT_ArrayInitializerLSquare) &&

&BreakConstructorInitializersToken =

(BreakConstructorInitializersToken.

(TT_CtorInitializerColon) &&

(State.Column + State.Line->Last->TotalLength -

.TotalLength >

CurrentState.BreakBeforeParameter) &&

(!Current.isTrailingComment() || Current.NewlinesBefore > 0) &&

Style.

> 0 || Current.NewlinesBefore > 0)) {

(Current.is(TT_ObjCMethodExpr) &&

.isNot(TT_SelectorName) &&

State.Line->startsWith(TT_ObjCMethodSpecifier)) {

(Current.is(TT_SelectorName) &&

.isNot(tok::at) &&

CurrentState.ObjCSelectorNameFound && CurrentState.BreakBeforeParameter &&

!Current.startsSequence(TT_SelectorName, tok::colon, tok::caret))) {

NewLineColumn = getNewLineColumn(State);

(Current.isMemberAccess() && Style.

!= 0 &&

(State.Column > NewLineColumn ||

Current.NestingLevel < State.StartOfLineLevel)) {

(CurrentState.CallContinuation != 0 ||

CurrentState.BreakBeforeParameter) &&

!(State.Column <= NewLineColumn && Style.

()) &&

!(

.closesScopeAfterBlock() && State.Column <= NewLineColumn)) {

(

.ClosesTemplateDeclaration && CurrentState.BreakBeforeParameter &&

Current.CanBreakBefore) {

(State.Line->First->isNot(tok::kw_enum) && State.Column <= NewLineColumn)

.is(tok::comma) || Current.NestingLevel < 2) &&

!

.isOneOf(tok::kw_return, tok::lessless, tok::at,

!

.isOneOf(TT_InlineASMColon, TT_ConditionalExpr) &&

nextIsMultilineString(State)) {

(

.is(TT_BinaryOperator) && Current.CanBreakBefore) {

PreviousPrecedence =

.getPrecedence();

CurrentState.BreakBeforeParameter && !Current.isTrailingComment()) {

LHSIsBinaryExpr =

IsComparison =

.Previous->isNot(TT_BinaryOperator);

}

(Current.is(TT_BinaryOperator) && Current.CanBreakBefore &&

CurrentState.BreakBeforeParameter) {

(Current.is(tok::lessless) && Current.isNot(TT_OverloadedOperator) &&

CurrentState.BreakBeforeParameter && CurrentState.FirstLessLess == 0) {

(Current.NestingLevel == 0 && !Current.isTrailingComment()) {

(

.ClosesTemplateDeclaration) {

(Current.is(tok::kw_concept)) {

(Current.is(TT_RequiresClause)) {

Current.NewlinesBefore > 0);

(

.is(TT_FunctionAnnotationRParen) &&

(

.is(TT_LeadingJavaAnnotation) && Current.isNot(tok::l_paren) &&

Current.isNot(TT_LeadingJavaAnnotation)) {

llvm::StringSet<> BreakBeforeDecoratedTokens = {

,

,

(BreakBeforeDecoratedTokens.contains(Current.TokenText))

(Current.is(TT_FunctionDeclarationName) &&

!State.Line->ReturnTypeWrapped &&

CurrentState.BreakBeforeParameter) {

!Current.isOneOf(tok::r_brace, tok::comment)) {

(Current.is(tok::lessless) &&

(

.Tok.isLiteral() && (

.TokenText.ends_with(

) ||

.TokenText ==

)))) {

(State.NoContinuation)

ExtraSpaces) {

assert(State.NextToken->Previous);

assert(!State.Stack.empty());

State.NoContinuation =

;

(Current.is(TT_ImplicitStringLiteral) &&

(!

.Tok.getIdentifierInfo() ||

.Tok.getIdentifierInfo()->getPPKeywordID() ==

tok::pp_not_keyword)) {

(Current.LastNewlineOffset != 0) {

State.Column = EndColumn;

StartColumn =

assert(EndColumn >= StartColumn);

State.Column += EndColumn - StartColumn;

moveStateToNextToken(State, DryRun,

);

Penalty = 0;

Penalty = addTokenOnNewLine(State, DryRun);

addTokenOnCurrentLine(State, DryRun, ExtraSpaces);

moveStateToNextToken(State, DryRun, Newline) + Penalty;

ContinuationIndenter::addTokenOnCurrentLine(

&State,

DryRun,

ExtraSpaces) {

assert(State.NextToken->Previous);

&CurrentState = State.Stack.back();

DisallowLineBreaksOnThisLine =

Style.

() && [&] {

(

.is(TT_BlockComment) && Current.SpacesRequiredBefore == 0)

*PrevNonComment = Current.getPreviousNonComment();

(!PrevNonComment || PrevNonComment->isNot(tok::l_paren))

(Current.isOneOf(tok::comment, tok::l_paren, TT_LambdaLSquare))

BlockParameterCount = PrevNonComment->BlockParameterCount;

(BlockParameterCount == 0)

(BlockParameterCount > 1)

(!PrevNonComment->Role)

Comma = PrevNonComment->Role->lastComma();

Next = Comma->getNextNonComment();

!Next->isOneOf(TT_LambdaLSquare, tok::l_brace, tok::caret);

(DisallowLineBreaksOnThisLine)

State.NoLineBreak =

;

(Current.is(tok::equal) &&

(State.Line->First->is(tok::kw_for) || Current.NestingLevel == 0) &&

CurrentState.VariablePos == 0 &&

.Previous->isNot(TT_DesignatedInitializerPeriod))) {

CurrentState.VariablePos = State.Column;

FormatToken *Tok = &

;

(Tok && CurrentState.VariablePos >= Tok->ColumnWidth) {

CurrentState.VariablePos -= Tok->ColumnWidth;

(Tok->SpacesRequiredBefore != 0)

(

.PartOfMultiVariableDeclStmt)

CurrentState.LastSpace = CurrentState.VariablePos;

Spaces = Current.SpacesRequiredBefore + ExtraSpaces;

PPColumnCorrection = 0;

.is(tok::hash) && State.FirstIndent > 0 &&

Spaces += State.FirstIndent;

PPColumnCorrection = -1;

State.Column + Spaces + PPColumnCorrection,

, State.Line->InMacroBody);

Current.is(TT_InheritanceColon)) {

CurrentState.NoLineBreak =

;

.is(TT_InheritanceColon)) {

CurrentState.NoLineBreak =

;

(Current.is(TT_SelectorName) && !CurrentState.ObjCSelectorNameFound) {

MinIndent = std::max(

FirstColonPos = State.Column + Spaces + Current.ColumnWidth;

(Current.LongestObjCSelectorName == 0)

CurrentState.AlignColons =

;

(MinIndent + Current.LongestObjCSelectorName > FirstColonPos)

CurrentState.ColonPos = MinIndent + Current.LongestObjCSelectorName;

CurrentState.ColonPos = FirstColonPos;

IsOpeningBracket = [&](

FormatToken &Tok) {

IsStartOfBracedList = [&]() {

Tok.is(tok::l_brace) && Tok.isNot(

) &&

(!Tok.isOneOf(tok::l_paren, TT_TemplateOpener, tok::l_square) &&

!IsStartOfBracedList()) {

(Tok.Previous->isIf())

!Tok.Previous->isOneOf(TT_CastRParen, tok::kw_for, tok::kw_while,

IsFunctionCallParen = [](

FormatToken &Tok) {

Tok.is(tok::l_paren) && Tok.ParameterCount > 0 && Tok.Previous &&

Tok.Previous->is(tok::identifier);

IsInTemplateString = [

](

FormatToken &Tok) {

(

*Prev = &Tok; Prev; Prev = Prev->Previous) {

(Prev->is(TT_TemplateString) && Prev->opensScope())

(Prev->opensScope() ||

(Prev->is(TT_TemplateString) && Prev->closesScope())) {

StartsSimpleOneArgList = [&](

FormatToken &TokAfterLParen) {

assert(TokAfterLParen.isNot(tok::comment) || TokAfterLParen.Next);

TokAfterLParen.is(tok::comment) ? *TokAfterLParen.Next : TokAfterLParen;

(!Tok.FakeLParens.empty() && Tok.FakeLParens.back() >

)

(Tok.is(tok::kw_new) || Tok.startsSequence(tok::coloncolon, tok::kw_new))

(Tok.is(TT_UnaryOperator) ||

Tok.isOneOf(tok::ellipsis, Keywords.

))) {

*

= Tok.Previous;

TT_LambdaDefinitionLParen) &&

!IsFunctionCallParen(*

))) {

(IsOpeningBracket(Tok) || IsInTemplateString(Tok))

*Next = Tok.Next;

!Next || Next->isMemberAccess() ||

Next->is(TT_FunctionDeclarationLParen) || IsFunctionCallParen(*Next);

IsOpeningBracket(

) && State.Column > getNewLineColumn(State) &&

!StartsSimpleOneArgList(Current)) {

CurrentState.NoLineBreak =

;

CurrentState.NoLineBreak =

;

!CurrentState.IsCSharpGenericTypeConstraint &&

.opensScope() &&

.isNot(TT_TableGenDAGArgOpener) &&

.isNot(TT_TableGenDAGArgOpenerToBreak) &&

!(Current.MacroParent &&

.MacroParent) &&

(Current.isNot(TT_LineComment) ||

!IsInTemplateString(Current)) {

CurrentState.Indent = State.Column + Spaces;

CurrentState.IsAligned =

;

CurrentState.NoLineBreak =

;

CurrentState.NoLineBreak =

;

State.Column > getNewLineColumn(State)) {

CurrentState.ContainsUnwrappedBuilder =

;

CurrentState.NoLineBreak =

;

(Current.isMemberAccess() &&

.is(tok::r_paren) &&

CurrentState.NoLineBreak =

;

FormatToken *

= Current.getPreviousNonComment();

(Current.isNot(tok::comment) &&

&&

(

->isOneOf(TT_BinaryOperator, tok::comma) ||

(

->is(TT_ConditionalExpr) &&

->is(tok::colon))) &&

!

->isOneOf(TT_OverloadedOperator, TT_CtorInitializerComma) &&

BreakBeforeOperator =

->MustBreakBefore ||

->is(tok::lessless) ||

(

->is(TT_BinaryOperator) &&

HasTwoOperands =

->OperatorIndex == 0 && !

->NextOperator &&

->isNot(TT_ConditionalExpr);

((!BreakBeforeOperator &&

(!CurrentState.LastOperatorWrapped && BreakBeforeOperator)) {

CurrentState.NoLineBreakInOperand =

;

State.Column += Spaces;

(Current.isNot(tok::comment) &&

.is(tok::l_paren) &&

CurrentState.LastSpace = State.Column;

CurrentState.NestedBlockIndent = State.Column;

}

(!Current.isOneOf(tok::comment, tok::caret) &&

.isNot(TT_OverloadedOperator)) ||

CurrentState.LastSpace = State.Column;

}

(

.is(TT_CtorInitializerColon) &&

(!Current.isTrailingComment() || Current.NewlinesBefore > 0) &&

CurrentState.Indent = State.Column;

CurrentState.LastSpace = State.Column;

}

(

.isOneOf(TT_ConditionalExpr, TT_CtorInitializerColon)) {

CurrentState.LastSpace = State.Column;

}

(

.is(TT_BinaryOperator) &&

Current.StartsBinaryExpression)) {

CurrentState.LastSpace = State.Column;

}

(

.is(TT_InheritanceColon)) {

CurrentState.Indent = State.Column;

CurrentState.LastSpace = State.Column;

}

(Current.is(TT_CSharpGenericTypeConstraintColon)) {

CurrentState.ColonPos = State.Column;

}

(

.opensScope()) {

FormatToken *Next =

.MatchingParen->getNextNonComment();

(Next && Next->isMemberAccess() && State.Stack.size() > 1 &&

State.Stack[State.Stack.size() - 2].CallContinuation == 0) {

CurrentState.LastSpace = State.Column;

ContinuationIndenter::addTokenOnNewLine(LineState &State,

FormatToken &Current = *State.NextToken;

assert(State.NextToken->Previous);

FormatToken &

= *State.NextToken->Previous;

&CurrentState = State.Stack.back();

Penalty = 0;

FormatToken *PreviousNonComment = Current.getPreviousNonComment();

FormatToken *NextNonComment =

.getNextNonComment();

(!NextNonComment)

NextNonComment = &Current;

(!CurrentState.ContainsLineBreak)

CurrentState.ContainsLineBreak =

;

Penalty += State.NextToken->SplitPenalty;

(NextNonComment->is(tok::lessless) && CurrentState.FirstLessLess == 0 &&

CurrentState.BreakBeforeParameter)) {

State.Column = getNewLineColumn(State);

(State.Column > State.FirstIndent) {

(Current.isNot(TT_LambdaArrow) &&

(!Style.

() || Current.NestingLevel != 0 ||

!PreviousNonComment || PreviousNonComment->isNot(tok::equal) ||

CurrentState.NestedBlockIndent = State.Column;

(NextNonComment->isMemberAccess()) {

(CurrentState.CallContinuation == 0)

CurrentState.CallContinuation = State.Column;

}

(NextNonComment->is(TT_SelectorName)) {

(!CurrentState.ObjCSelectorNameFound) {

(NextNonComment->LongestObjCSelectorName == 0) {

CurrentState.AlignColons =

;

CurrentState.ColonPos =

? std::max(CurrentState.Indent,

: CurrentState.Indent) +

NextNonComment->ColumnWidth);

}

(CurrentState.AlignColons &&

CurrentState.ColonPos <= NextNonComment->ColumnWidth) {

CurrentState.ColonPos = State.Column + NextNonComment->ColumnWidth;

}

(PreviousNonComment && PreviousNonComment->is(tok::colon) &&

PreviousNonComment->isOneOf(TT_ObjCMethodExpr, TT_DictLiteral)) {

(State.Stack.size() > 1) {

State.Stack[State.Stack.size() - 2].LastSpace =

std::max(CurrentState.LastSpace, CurrentState.Indent) +

((PreviousNonComment &&

PreviousNonComment->isOneOf(tok::comma, tok::semi) &&

!CurrentState.AvoidBinPacking) ||

CurrentState.BreakBeforeParameter =

;

(PreviousNonComment &&

(PreviousNonComment->isOneOf(TT_TemplateCloser, TT_JavaAnnotation) ||

PreviousNonComment->ClosesRequiresClause) &&

Current.NestingLevel == 0) {

CurrentState.BreakBeforeParameter =

;

(NextNonComment->is(tok::question) ||

(PreviousNonComment && PreviousNonComment->is(tok::question))) {

CurrentState.BreakBeforeParameter =

;

(Current.is(TT_BinaryOperator) && Current.CanBreakBefore)

CurrentState.BreakBeforeParameter =

;

(Current.is(tok::r_brace) && Current.MatchingParen &&

!Current.MatchingParen->Children.empty()) {

MaxEmptyLinesToKeep = 1;

std::max(1u, std::min(Current.NewlinesBefore, MaxEmptyLinesToKeep));

ContinuePPDirective =

CurrentState.IsAligned, ContinuePPDirective);

(!Current.isTrailingComment())

CurrentState.LastSpace = State.Column;

(Current.is(tok::lessless)) {

CurrentState.LastSpace += 3;

State.StartOfLineLevel = Current.NestingLevel;

State.LowestLevelOnLine = Current.NestingLevel;

NestedBlockSpecialCase =

(!Style.

() && Current.is(tok::r_brace) && State.Stack.size() > 1 &&

State.Stack[State.Stack.size() - 2].NestedBlockInlined) ||

NestedBlockSpecialCase =

NestedBlockSpecialCase ||

(Current.MatchingParen &&

Current.MatchingParen->is(TT_RequiresExpressionLBrace));

(!NestedBlockSpecialCase) {

ParentLevelIt = std::next(State.Stack.rbegin());

Current.MatchingParen && Current.MatchingParen->is(TT_LambdaLBrace)) {

FindCurrentLevel = [&](

&It) {

std::find_if(It, State.Stack.rend(), [](

&PState) {

return PState.Tok != nullptr;

MaybeIncrement = [&](

&It) {

It != State.Stack.rend() ? std::next(It) : It;

LambdaLevelIt = FindCurrentLevel(State.Stack.rbegin());

LevelContainingLambdaIt =

FindCurrentLevel(MaybeIncrement(LambdaLevelIt));

ParentLevelIt = MaybeIncrement(LevelContainingLambdaIt);

(

I = ParentLevelIt,

= State.Stack.rend(); I !=

; ++I)

I->BreakBeforeParameter =

;

(PreviousNonComment &&

!PreviousNonComment->isOneOf(tok::comma, tok::colon, tok::semi) &&

((PreviousNonComment->isNot(TT_TemplateCloser) &&

!PreviousNonComment->ClosesRequiresClause) ||

Current.NestingLevel != 0) &&

!PreviousNonComment->isOneOf(

TT_BinaryOperator, TT_FunctionAnnotationRParen, TT_JavaAnnotation,

TT_LeadingJavaAnnotation) &&

Current.isNot(TT_BinaryOperator) && !PreviousNonComment->opensScope() &&

Current.isNot(TT_LambdaLBrace))) {

CurrentState.BreakBeforeParameter =

;

(PreviousNonComment &&

(PreviousNonComment->isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) ||

CurrentState.BreakBeforeClosingBrace =

;

(PreviousNonComment && PreviousNonComment->is(tok::l_paren)) {

CurrentState.BreakBeforeClosingParen =

(CurrentState.AvoidBinPacking) {

PreviousIsBreakingCtorInitializerColon =

PreviousNonComment && PreviousNonComment->is(TT_CtorInitializerColon) &&

AllowAllConstructorInitializersOnNextLine =

(!(

.isOneOf(tok::l_paren, tok::l_brace, TT_BinaryOperator) ||

PreviousIsBreakingCtorInitializerColon) ||

State.Line->MustBeDeclaration) ||

!State.Line->MustBeDeclaration) ||

(!AllowAllConstructorInitializersOnNextLine &&

PreviousIsBreakingCtorInitializerColon) ||

CurrentState.BreakBeforeParameter =

;

(PreviousIsBreakingCtorInitializerColon &&

AllowAllConstructorInitializersOnNextLine) {

CurrentState.BreakBeforeParameter =

;

CurrentState.BreakBeforeParameter =

;

ContinuationIndenter::getNewLineColumn(

LineState &State) {

(!State.NextToken || !State.NextToken->Previous)

FormatToken &Current = *State.NextToken;

&CurrentState = State.Stack.back();

(CurrentState.IsCSharpGenericTypeConstraint &&

Current.isNot(TT_CSharpGenericTypeConstraint)) {

CurrentState.ColonPos + 2;

FormatToken &

= *Current.Previous;

ContinuationIndent =

std::max(CurrentState.LastSpace, CurrentState.Indent) +

FormatToken *PreviousNonComment = Current.getPreviousNonComment();

FormatToken *NextNonComment =

.getNextNonComment();

(!NextNonComment)

NextNonComment = &Current;

std::max(CurrentState.LastSpace,

(Style.

() && PreviousNonComment &&

State.FirstIndent;

State.Line->First->is(tok::kw_enum)) {

(Style.

* State.Line->First->IndentLevel) +

((NextNonComment->is(tok::l_brace) && NextNonComment->is(

)) ||

(Current.NestingLevel == 0 ||

State.NextToken->is(TT_LambdaLBrace))) {

State.FirstIndent;

CurrentState.Indent;

(Current.is(TT_LambdaArrow) &&

.isOneOf(tok::kw_noexcept, tok::kw_mutable, tok::kw_constexpr,

tok::kw_consteval, tok::kw_static, TT_AttributeSquare)) {

ContinuationIndent;

((Current.isOneOf(tok::r_brace, tok::r_square) ||

State.Stack.size() > 1) {

(Current.closesBlockOrBlockTypeList(Style))

State.Stack[State.Stack.size() - 2].NestedBlockIndent;

(Current.MatchingParen && Current.MatchingParen->is(

))

State.Stack[State.Stack.size() - 2].LastSpace;

State.FirstIndent;

(Current.is(tok::r_paren) && State.Stack.size() > 1 &&

Current.Next->isOneOf(tok::semi, tok::kw_const, tok::l_brace))) {

State.Stack[State.Stack.size() - 2].LastSpace;

(Style.

() && Current.is(TT_TableGenDAGArgCloser) &&

State.Stack.size() > 1) {

State.Stack[State.Stack.size() - 2].LastSpace;

(Current.is(tok::r_paren) ||

(Current.is(tok::r_brace) && Current.MatchingParen &&

State.Stack.size() > 1) {

State.Stack[State.Stack.size() - 2].LastSpace;

(NextNonComment->is(TT_TemplateString) && NextNonComment->closesScope())

State.Stack[State.Stack.size() - 2].LastSpace;

(Current.is(tok::identifier) && Current.Next &&

(!Style.

() || Current.Next->is(tok::colon)) &&

(Current.Next->is(TT_DictLiteral) ||

(Style.

() && Current.Next->isOneOf(tok::less, tok::l_brace)))) {

CurrentState.Indent;

(NextNonComment->is(TT_ObjCStringLiteral) &&

State.StartOfStringLiteral != 0) {

State.StartOfStringLiteral - 1;

(NextNonComment->isStringLiteral() && State.StartOfStringLiteral != 0)

State.StartOfStringLiteral;

(NextNonComment->is(tok::lessless) && CurrentState.FirstLessLess != 0)

CurrentState.FirstLessLess;

(NextNonComment->isMemberAccess()) {

(CurrentState.CallContinuation == 0)

ContinuationIndent;

CurrentState.CallContinuation;

(CurrentState.QuestionColumn != 0 &&

((NextNonComment->is(tok::colon) &&

NextNonComment->is(TT_ConditionalExpr)) ||

.is(TT_ConditionalExpr))) {

(((NextNonComment->is(tok::colon) && NextNonComment->Next &&

!NextNonComment->Next->FakeLParens.empty() &&

(

.is(tok::colon) && !Current.FakeLParens.empty() &&

!CurrentState.IsWrappedConditional) {

Indent = CurrentState.Indent;

CurrentState.QuestionColumn;

(

.is(tok::comma) && CurrentState.VariablePos != 0)

CurrentState.VariablePos;

(Current.is(TT_RequiresClause)) {

CurrentState.Indent;

(NextNonComment->isOneOf(TT_CtorInitializerColon, TT_InheritanceColon,

TT_InheritanceComma)) {

((PreviousNonComment &&

(PreviousNonComment->ClosesTemplateDeclaration ||

PreviousNonComment->ClosesRequiresClause ||

(PreviousNonComment->is(TT_AttributeMacro) &&

Current.isNot(tok::l_paren)) ||

PreviousNonComment->isOneOf(

TT_AttributeRParen, TT_AttributeSquare, TT_FunctionAnnotationRParen,

TT_JavaAnnotation, TT_LeadingJavaAnnotation))) ||

NextNonComment->isOneOf(tok::kw_operator, TT_FunctionDeclarationName))) {

std::max(CurrentState.LastSpace, CurrentState.Indent);

(NextNonComment->is(TT_SelectorName)) {

(!CurrentState.ObjCSelectorNameFound) {

MinIndent = CurrentState.Indent;

MinIndent = std::max(MinIndent,

std::max(NextNonComment->LongestObjCSelectorName,

NextNonComment->ColumnWidth) -

NextNonComment->ColumnWidth;

(!CurrentState.AlignColons)

CurrentState.Indent;

(CurrentState.ColonPos > NextNonComment->ColumnWidth)

CurrentState.ColonPos - NextNonComment->ColumnWidth;

CurrentState.Indent;

(NextNonComment->is(tok::colon) && NextNonComment->is(TT_ObjCMethodExpr))

CurrentState.ColonPos;

(NextNonComment->is(TT_ArraySubscriptLSquare)) {

(CurrentState.StartOfArraySubscripts != 0) {

CurrentState.StartOfArraySubscripts;

CurrentState.Indent;

ContinuationIndent;

(State.Line->InPragmaDirective) {

FormatToken *PragmaType = State.Line->First->Next->Next;

(PragmaType && PragmaType->TokenText ==

)

(NextNonComment->is(tok::identifier) && NextNonComment->FakeRParens == 0 &&

NextNonComment->Next && NextNonComment->Next->is(TT_ObjCMethodExpr)) {

CurrentState.Indent;

(NextNonComment->isOneOf(TT_StartOfName, TT_PointerOrReference) ||

.isOneOf(tok::coloncolon, tok::equal, TT_JsTypeColon)) {

ContinuationIndent;

(PreviousNonComment && PreviousNonComment->is(tok::colon) &&

PreviousNonComment->isOneOf(TT_ObjCMethodExpr, TT_DictLiteral)) {

ContinuationIndent;

(NextNonComment->is(TT_CtorInitializerComma))

CurrentState.Indent;

(PreviousNonComment && PreviousNonComment->is(TT_CtorInitializerColon) &&

CurrentState.Indent;

(PreviousNonComment && PreviousNonComment->is(TT_InheritanceColon) &&

CurrentState.Indent;

.isNot(TT_TableGenDAGArgOperatorToBreak) &&

!Current.isBinaryOperator() &&

!Current.isOneOf(tok::colon, tok::comment)) {

ContinuationIndent;

(Current.is(TT_ProtoExtensionLSquare))

CurrentState.Indent;

(Current.isBinaryOperator() && CurrentState.UnindentOperator) {

CurrentState.Indent - Current.Tok.getLength() -

Current.SpacesRequiredBefore;

(Current.is(tok::comment) && NextNonComment->isBinaryOperator() &&

CurrentState.UnindentOperator) {

CurrentState.Indent - NextNonComment->Tok.getLength() -

NextNonComment->SpacesRequiredBefore;

(CurrentState.Indent == State.FirstIndent && PreviousNonComment &&

!PreviousNonComment->isOneOf(tok::r_brace, TT_CtorInitializerComma)) {

CurrentState.Indent;

(

->isNot(tok::l_paren))

(

->ParameterCount > 1)

ContinuationIndenter::moveStateToNextToken(LineState &State,

DryRun,

Newline) {

assert(State.Stack.size());

FormatToken &Current = *State.NextToken;

&CurrentState = State.Stack.back();

(Current.is(TT_CSharpGenericTypeConstraint))

CurrentState.IsCSharpGenericTypeConstraint =

;

(Current.isOneOf(tok::comma, TT_BinaryOperator))

CurrentState.NoLineBreakInOperand =

;

(Current.isOneOf(TT_InheritanceColon, TT_CSharpGenericTypeConstraintColon))

CurrentState.AvoidBinPacking =

;

(Current.is(tok::lessless) && Current.isNot(TT_OverloadedOperator)) {

(CurrentState.FirstLessLess == 0)

CurrentState.FirstLessLess = State.Column;

CurrentState.LastOperatorWrapped = Newline;

(Current.is(TT_BinaryOperator) && Current.isNot(tok::lessless))

CurrentState.LastOperatorWrapped = Newline;

(Current.is(TT_ConditionalExpr) && Current.Previous &&

Current.Previous->isNot(TT_ConditionalExpr)) {

CurrentState.LastOperatorWrapped = Newline;

(Current.is(TT_ArraySubscriptLSquare) &&

CurrentState.StartOfArraySubscripts == 0) {

CurrentState.StartOfArraySubscripts = State.Column;

IsWrappedConditional = [](

FormatToken &Tok) {

(!(Tok.is(TT_ConditionalExpr) && Tok.is(tok::question)))

(Tok.MustBreakBefore)

FormatToken *Next = Tok.getNextNonComment();

Next && Next->MustBreakBefore;

(IsWrappedConditional(Current))

CurrentState.IsWrappedConditional =

;

CurrentState.QuestionColumn = State.Column;

FormatToken *

= Current.Previous;

CurrentState.QuestionColumn = State.Column;

(!Current.opensScope() && !Current.closesScope() &&

Current.isNot(TT_PointerOrReference)) {

State.LowestLevelOnLine =

std::min(State.LowestLevelOnLine, Current.NestingLevel);

(Current.isMemberAccess())

CurrentState.StartOfFunctionCall = !Current.NextOperator ? 0 : State.Column;

(Current.is(TT_SelectorName))

CurrentState.ObjCSelectorNameFound =

;

(Current.is(TT_CtorInitializerColon) &&

CurrentState.NestedBlockIndent = CurrentState.Indent;

CurrentState.AvoidBinPacking =

;

CurrentState.BreakBeforeParameter =

CurrentState.BreakBeforeParameter =

;

(Current.is(TT_CtorInitializerColon) &&

CurrentState.Indent =

CurrentState.NestedBlockIndent = CurrentState.Indent;

CurrentState.AvoidBinPacking =

;

CurrentState.BreakBeforeParameter =

;

(Current.is(TT_InheritanceColon)) {

CurrentState.Indent =

(Current.isOneOf(TT_BinaryOperator, TT_ConditionalExpr) && Newline)

CurrentState.NestedBlockIndent = State.Column + Current.ColumnWidth + 1;

(Current.isOneOf(TT_LambdaLSquare, TT_LambdaArrow))

CurrentState.LastSpace = State.Column;

(Current.is(TT_RequiresExpression) &&

CurrentState.NestedBlockIndent = State.Column;

FormatToken *

= Current.getPreviousNonComment();

(Current.isNot(tok::comment) && !Current.ClosesRequiresClause &&

&&

->isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) &&

->isNot(TT_DictLiteral) && State.Stack.size() > 1 &&

!CurrentState.HasMultipleNestedBlocks) {

(State.Stack[State.Stack.size() - 2].NestedBlockInlined && Newline)

(ParenState &PState : llvm::drop_end(State.Stack))

PState.NoLineBreak =

;

State.Stack[State.Stack.size() - 2].NestedBlockInlined =

;

(

&& (

->isOneOf(TT_BinaryOperator, TT_ConditionalExpr) ||

(

->isOneOf(tok::l_paren, tok::comma, tok::colon) &&

!

->isOneOf(TT_DictLiteral, TT_ObjCMethodExpr)))) {

CurrentState.NestedBlockInlined =

moveStatePastFakeLParens(State, Newline);

moveStatePastScopeCloser(State);

AllowBreak = !State.Stack.back().NoLineBreak &&

!State.Stack.back().NoLineBreakInOperand;

moveStatePastScopeOpener(State, Newline);

moveStatePastFakeRParens(State);

(Current.is(TT_ObjCStringLiteral) && State.StartOfStringLiteral == 0)

State.StartOfStringLiteral = State.Column + 1;

(Current.is(TT_CSharpStringLiteral) && State.StartOfStringLiteral == 0) {

State.StartOfStringLiteral = State.Column + 1;

}

(Current.is(TT_TableGenMultiLineString) &&

State.StartOfStringLiteral == 0) {

State.StartOfStringLiteral = State.Column + 1;

}

(Current.isStringLiteral() && State.StartOfStringLiteral == 0) {

State.StartOfStringLiteral = State.Column;

}

(!Current.isOneOf(tok::comment, tok::identifier, tok::hash) &&

!Current.isStringLiteral()) {

State.StartOfStringLiteral = 0;

State.Column += Current.ColumnWidth;

State.NextToken = State.NextToken->Next;

(Style.

() && State.NextToken &&

State.NextToken->MustBreakBefore &&

CurrentState.Indent = State.FirstIndent;

handleEndOfLine(Current, State, DryRun, AllowBreak, Newline);

Current.Role->formatFromToken(State,

, DryRun);

Penalty +=

->Role->formatAfterToken(State,

, DryRun);

ContinuationIndenter::moveStatePastFakeLParens(LineState &State,

FormatToken &Current = *State.NextToken;

(Current.FakeLParens.empty())

FormatToken *

= Current.getPreviousNonComment();

SkipFirstExtraIndent =

->isOneOf(tok::semi, tok::kw_return, TT_RequiresClause) ||

(

&PrecedenceLevel : llvm::reverse(Current.FakeLParens)) {

&CurrentState = State.Stack.back();

ParenState NewParenState = CurrentState;

NewParenState.Tok =

;

NewParenState.ContainsLineBreak =

;

NewParenState.LastOperatorWrapped =

;

NewParenState.IsChainedConditional =

;

NewParenState.IsWrappedConditional =

;

NewParenState.UnindentOperator =

;

NewParenState.NoLineBreak =

NewParenState.NoLineBreak || CurrentState.NoLineBreakInOperand;

NewParenState.AvoidBinPacking =

;

(!Current.isTrailingComment() &&

PrecedenceLevel >

|| Current.NestingLevel == 0) &&

TT_TableGenDAGArgListCommaToBreak)))) {

NewParenState.Indent = std::max(

std::max(State.Column, NewParenState.Indent), CurrentState.LastSpace);

(

&&

->endsSequence(tok::l_paren, tok::kw__Generic) &&

State.Stack.size() > 1) {

NewParenState.Indent = State.Stack[State.Stack.size() - 2].Indent +

NewParenState.UnindentOperator =

;

NewParenState.IsAligned =

;

NewParenState.LastSpace = std::max(NewParenState.LastSpace, State.Column);

Current.isNot(TT_UnaryOperator) &&

NewParenState.StartOfFunctionCall = State.Column;

&PrecedenceLevel == &Current.FakeLParens.back() &&

!CurrentState.IsWrappedConditional) {

NewParenState.IsChainedConditional =

;

NewParenState.UnindentOperator = State.Stack.back().UnindentOperator;

!Current.isTrailingComment())) {

NewParenState.BreakBeforeParameter =

;

State.Stack.push_back(NewParenState);

SkipFirstExtraIndent =

;

ContinuationIndenter::moveStatePastFakeRParens(LineState &State) {

(

i = 0, e = State.NextToken->FakeRParens; i != e; ++i) {

VariablePos = State.Stack.back().VariablePos;

(State.Stack.size() == 1) {

State.Stack.pop_back();

State.Stack.back().VariablePos = VariablePos;

State.Stack.back().LastSpace -= Style.

;

ContinuationIndenter::moveStatePastScopeOpener(LineState &State,

FormatToken &Current = *State.NextToken;

(!Current.opensScope())

&CurrentState = State.Stack.back();

(Current.isOneOf(tok::less, tok::l_paren) &&

CurrentState.IsCSharpGenericTypeConstraint) {

(Current.MatchingParen && Current.is(

)) {

moveStateToNewBlock(State, Newline);

LastSpace = CurrentState.LastSpace;

AvoidBinPacking;

BreakBeforeParameter =

;

NestedBlockIndent = std::max(CurrentState.StartOfFunctionCall,

CurrentState.NestedBlockIndent);

(Current.isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) ||

(Current.opensBlockOrBlockTypeList(Style)) {

std::min(State.Column, CurrentState.NestedBlockIndent);

}

(Current.is(tok::l_brace)) {

FormatToken *NextNonComment = Current.getNextNonComment();

EndsInComma = Current.MatchingParen &&

Current.MatchingParen->Previous &&

Current.MatchingParen->Previous->is(tok::comma);

AvoidBinPacking = EndsInComma || Current.is(TT_DictLiteral) ||

(NextNonComment && NextNonComment->isOneOf(

TT_DesignatedInitializerPeriod,

TT_DesignatedInitializerLSquare));

BreakBeforeParameter = EndsInComma;

(Current.ParameterCount > 1)

NestedBlockIndent = std::max(NestedBlockIndent, State.Column + 1);

std::max(CurrentState.LastSpace, CurrentState.StartOfFunctionCall);

(Style.

() && Current.is(TT_TableGenDAGArgOpenerToBreak) &&

FormatToken *Next = Current.Next;

(Next && Next->is(TT_TableGenDAGArgOperatorID))

NewIndent = State.Column + Next->TokenText.size() + 2;

(Current.is(tok::less) && Current.ParentBracket == tok::l_paren) {

NewIndent = std::max(NewIndent, CurrentState.Indent);

LastSpace = std::max(LastSpace, CurrentState.Indent);

Current.MatchingParen &&

Current.MatchingParen->getPreviousNonComment() &&

Current.MatchingParen->getPreviousNonComment()->is(tok::comma);

ObjCBinPackProtocolList =

BinPackDeclaration =

(State.Line->Type ==

&& ObjCBinPackProtocolList);

GenericSelection =

Current.getPreviousNonComment() &&

Current.getPreviousNonComment()->is(tok::kw__Generic);

(CurrentState.IsCSharpGenericTypeConstraint) || GenericSelection ||

(State.Line->MustBeDeclaration && !BinPackDeclaration) ||

(Current.is(TT_ObjCMethodExpr) && Current.MatchingParen &&

BreakBeforeParameter =

;

(

FormatToken *Tok = &Current;

Tok && Tok != Current.MatchingParen; Tok = Tok->Next) {

(Tok->MustBreakBefore ||

(Tok->CanBreakBefore && Tok->NewlinesBefore > 0)) {

BreakBeforeParameter =

;

BreakBeforeParameter =

;

Current.Children.empty() &&

!Current.isOneOf(TT_DictLiteral, TT_ArrayInitializerLSquare) &&

(CurrentState.NoLineBreak || CurrentState.NoLineBreakInOperand ||

(Current.is(TT_TemplateOpener) &&

CurrentState.ContainsUnwrappedBuilder));

State.Stack.push_back(

ParenState(&Current, NewIndent, LastSpace, AvoidBinPacking, NoLineBreak));

&NewState = State.Stack.back();

NewState.NestedBlockIndent = NestedBlockIndent;

NewState.BreakBeforeParameter = BreakBeforeParameter;

NewState.HasMultipleNestedBlocks = (Current.BlockParameterCount > 1);

Current.is(tok::l_paren)) {

FormatToken

*next = Current.Next;

(next->is(TT_LambdaLSquare)) {

NewState.HasMultipleNestedBlocks =

;

NewState.IsInsideObjCArrayLiteral = Current.is(TT_ArrayInitializerLSquare) &&

Current.Previous->is(tok::at);

ContinuationIndenter::moveStatePastScopeCloser(LineState &State) {

FormatToken &Current = *State.NextToken;

(!Current.closesScope())

(State.Stack.size() > 1 &&

(Current.isOneOf(tok::r_paren, tok::r_square, TT_TemplateString) ||

(Current.is(tok::r_brace) && State.NextToken != State.Line->First) ||

State.NextToken->is(TT_TemplateCloser) ||

State.NextToken->is(TT_TableGenListCloser) ||

(Current.is(tok::greater) && Current.is(TT_DictLiteral)))) {

State.Stack.pop_back();

&CurrentState = State.Stack.back();

(CurrentState.BreakBeforeParameter && Current.MatchingParen &&

Current.MatchingParen->Previous) {

FormatToken &CurrentScopeOpener = *Current.MatchingParen->Previous;

(CurrentScopeOpener.is(TT_ObjCMethodExpr) &&

CurrentScopeOpener.MatchingParen) {

NecessarySpaceInLine =

CurrentScopeOpener.TotalLength - Current.TotalLength - 1;

(State.Column + Current.ColumnWidth + NecessarySpaceInLine <=

CurrentState.BreakBeforeParameter =

;

(Current.is(tok::r_square)) {

FormatToken *NextNonComment = Current.getNextNonComment();

(NextNonComment && NextNonComment->isNot(tok::l_square))

CurrentState.StartOfArraySubscripts = 0;

ContinuationIndenter::moveStateToNewBlock(LineState &State,

) {

State.NextToken->is(TT_LambdaLBrace) &&

!State.Line->MightBeFunctionDecl) {

State.Stack.back().NestedBlockIndent = State.FirstIndent;

NestedBlockIndent = State.Stack.back().NestedBlockIndent;

NewIndent =

NestedBlockIndent + (State.NextToken->is(TT_ObjCBlockLBrace)

State.NextToken->is(TT_LambdaLBrace);

State.Stack.push_back(ParenState(State.NextToken, NewIndent,

State.Stack.back().LastSpace,

, NoLineBreak));

State.Stack.back().NestedBlockIndent = NestedBlockIndent;

State.Stack.back().BreakBeforeParameter =

;

LastNewlinePos =

.find_last_of(

);

(LastNewlinePos == StringRef::npos) {

StartColumn +

0, TabWidth, Encoding);

ContinuationIndenter::reformatRawStringLiteral(

FormatToken &Current, LineState &State,

FormatStyle &RawStringStyle,

DryRun,

Newline) {

StartColumn = State.Column - Current.ColumnWidth;

StringRef NewDelimiter =

(NewDelimiter.empty())

NewDelimiter = OldDelimiter;

OldPrefixSize = 3 + OldDelimiter.size();

OldSuffixSize = 2 + OldDelimiter.size();

std::string RawText = std::string(

Current.TokenText.substr(OldPrefixSize).drop_back(OldSuffixSize));

(NewDelimiter != OldDelimiter) {

std::string CanonicalDelimiterSuffix = (

+ NewDelimiter +

).str();

(StringRef(RawText).contains(CanonicalDelimiterSuffix))

NewDelimiter = OldDelimiter;

NewPrefixSize = 3 + NewDelimiter.size();

NewSuffixSize = 2 + NewDelimiter.size();

FirstStartColumn = StartColumn + NewPrefixSize;

ContentStartsOnNewline = Current.TokenText[OldPrefixSize] ==

;

CurrentIndent =

(!Newline && Current.Next && Current.Next->is(tok::r_paren))

? State.Stack.back().NestedBlockIndent

: State.Stack.back().Indent;

NextStartColumn = ContentStartsOnNewline

LastStartColumn =

Current.NewlinesBefore ? FirstStartColumn - NewPrefixSize : CurrentIndent;

RawStringStyle, RawText, {tooling::Range(0, RawText.size())},

FirstStartColumn, NextStartColumn, LastStartColumn,

,

tooling::Replacements NoFixes;

addMultilineToken(Current, State);

(NewDelimiter != OldDelimiter) {

SourceLocation PrefixDelimiterStart =

Current.Tok.getLocation().getLocWithOffset(2);

PrefixErr = Whitespaces.

(tooling::Replacement(

SourceMgr, PrefixDelimiterStart, OldDelimiter.size(), NewDelimiter));

<<

<< llvm::toString(std::move(PrefixErr)) <<

;

SourceLocation SuffixDelimiterStart =

Current.Tok.getLocation().getLocWithOffset(Current.TokenText.size() -

1 - OldDelimiter.size());

SuffixErr = Whitespaces.

(tooling::Replacement(

SourceMgr, SuffixDelimiterStart, OldDelimiter.size(), NewDelimiter));

<<

<< llvm::toString(std::move(SuffixErr)) <<

;

SourceLocation OriginLoc =

Current.Tok.getLocation().getLocWithOffset(OldPrefixSize);

(

tooling::Replacement &Fix : Fixes.first) {

SourceMgr, OriginLoc.getLocWithOffset(Fix.getOffset()),

Fix.getLength(), Fix.getReplacementText()));

llvm::errs() <<

<< llvm::toString(std::move(Err)) <<

;

*NewCode, FirstStartColumn, Style.

, Encoding);

State.Column = RawLastLineEndColumn + NewSuffixSize;

PrefixExcessCharacters =

? StartColumn + NewPrefixSize - Style.

ContentStartsOnNewline || (NewCode->find(

) != std::string::npos);

(ParenState &

: State.Stack)

.BreakBeforeParameter =

;

ContinuationIndenter::addMultilineToken(

FormatToken &Current,

(ParenState &

: State.Stack)

.BreakBeforeParameter =

;

ColumnsUsed = State.Column;

State.Column = Current.LastLineColumnWidth;

ContinuationIndenter::handleEndOfLine(

FormatToken &Current,

LineState &State,

DryRun,

AllowBreak,

Newline) {

Penalty = 0;

RawStringStyle = getRawStringStyle(Current, State);

(RawStringStyle && !Current.Finalized) {

Penalty = reformatRawStringLiteral(Current, State, *RawStringStyle, DryRun,

}

(Current.IsMultiline && Current.isNot(TT_BlockComment)) {

Penalty = addMultilineToken(Current, State);

LineState OriginalState = State;

Strict =

;

Exceeded =

;

std::tie(Penalty, Exceeded) = breakProtrudingToken(

Current, State, AllowBreak,

, Strict);

LineState StrictState = OriginalState;

StrictPenalty =

breakProtrudingToken(Current, StrictState, AllowBreak,

Strict = StrictPenalty <= Penalty;

Penalty = StrictPenalty;

State = StrictState;

breakProtrudingToken(Current, OriginalState, AllowBreak,

,

ExcessCharacters = State.Column -

(State);

(!Tok || Tok->isNot(tok::l_paren))

(Tok->is(TT_TemplateCloser)) {

(!Tok || Tok->isNot(tok::identifier))

std::optional<FormatStyle>

ContinuationIndenter::getRawStringStyle(

FormatToken &Current,

LineState &State) {

(!Current.isStringLiteral())

std::nullopt;

std::nullopt;

(!RawStringStyle && Delimiter->empty()) {

(!RawStringStyle)

std::nullopt;

RawStringStyle;

std::unique_ptr<BreakableToken>

ContinuationIndenter::createBreakableToken(

FormatToken &Current,

LineState &State,

AllowBreak) {

StartColumn = State.Column - Current.ColumnWidth;

(Current.isStringLiteral()) {

(Current.IsUnterminatedLiteral)

(State.Stack.back().IsInsideObjCArrayLiteral)

(Style.

() && Current.Previous &&

Current.Previous->isOneOf(tok::kw_export, Keywords.

)) {

StringRef

= Current.TokenText;

UnbreakableTailLength = (State.NextToken &&

(State))

: Current.UnbreakableTailLength;

.ends_with(

)) {

}

(Style.

() &&

.starts_with(

) &&

.ends_with(

)) {

}

(

.starts_with(

) &&

.ends_with(

)) {

std::make_unique<BreakableStringLiteralUsingOperators>(

Current, QuoteStyle,

UnbreakableTailLength, State.Line->InPPDirective, Encoding, Style);

((

.ends_with(Postfix =

) &&

(

.starts_with(Prefix =

) ||

.starts_with(Prefix =

) ||

.starts_with(Prefix =

) ||

.starts_with(Prefix =

) ||

.starts_with(Prefix =

) ||

.starts_with(Prefix =

))) ||

(

.starts_with(Prefix =

) &&

.ends_with(Postfix =

))) {

std::make_unique<BreakableStringLiteral>(

Current, StartColumn, Prefix, Postfix, UnbreakableTailLength,

State.Line->InPPDirective, Encoding, Style);

}

(Current.is(TT_BlockComment)) {

std::make_unique<BreakableBlockComment>(

Current, StartColumn, Current.OriginalColumn, !Current.Previous,

State.Line->InPPDirective, Encoding, Style, Whitespaces.

());

}

(Current.is(TT_LineComment) &&

(!Current.Previous ||

Current.Previous->isNot(TT_ImplicitStringLiteral))) {

RegularComments = [&]() {

(

FormatToken *

= &Current;

&&

->is(TT_LineComment);

(!(

->TokenText.starts_with(

) ||

->TokenText.starts_with(

)))

CommentPragmasRegex.match(Current.TokenText.substr(2)) ||

std::make_unique<BreakableLineCommentSection>(

Current, StartColumn,

, Encoding, Style);

std::pair<unsigned, bool>

ContinuationIndenter::breakProtrudingToken(

FormatToken &Current,

LineState &State,

AllowBreak,

DryRun,

Strict) {

std::unique_ptr<const BreakableToken> Token =

createBreakableToken(Current, State, AllowBreak);

assert(Token->getLineCount() > 0);

(Current.is(TT_LineComment)) {

(ColumnLimit == 0) {

ColumnLimit = std::numeric_limits<

(ColumnLimit)>

();

(Current.UnbreakableTailLength >= ColumnLimit)

StartColumn = State.Column - Current.ColumnWidth;

NewBreakPenalty = Current.isStringLiteral()

Exceeded =

;

BreakInserted = Token->introducesBreakBeforeToken();

NewBreakBefore =

;

Reflow =

;

TailOffset = 0;

ContentStartColumn =

Token->getContentStartColumn(0,

);

RemainingTokenColumns =

Token->getRemainingLength(0, TailOffset, ContentStartColumn);

Token->adaptStartOfLine(0, Whitespaces);

ContentIndent = 0;

Penalty = 0;

LLVM_DEBUG(llvm::dbgs() <<

<< StartColumn <<

);

(

LineIndex = 0, EndIndex = Token->getLineCount();

LineIndex != EndIndex; ++LineIndex) {

LLVM_DEBUG(llvm::dbgs()

<<

<< LineIndex <<

<< Reflow <<

);

NewBreakBefore =

;

TryReflow = Reflow;

(ContentStartColumn + RemainingTokenColumns > ColumnLimit) {

LLVM_DEBUG(llvm::dbgs() <<

<< (ContentStartColumn + RemainingTokenColumns)

<<

<< ColumnLimit

<<

<< ContentStartColumn

<<

<< TailOffset <<

);

Token->getSplit(LineIndex, TailOffset, ColumnLimit,

ContentStartColumn, CommentPragmasRegex);

(

.first == StringRef::npos) {

(LineIndex < EndIndex - 1) {

(ContentStartColumn + RemainingTokenColumns - ColumnLimit);

LLVM_DEBUG(llvm::dbgs() <<

);

assert(

.first != 0);

(Token->supportsReflow()) {

ToSplitColumns = Token->getRangeLength(

LineIndex, TailOffset,

.first, ContentStartColumn);

LLVM_DEBUG(llvm::dbgs() <<

<< ToSplitColumns <<

);

LineIndex, TailOffset +

.first +

.second, ColumnLimit,

ContentStartColumn + ToSplitColumns + 1, CommentPragmasRegex);

ToNextSplitColumns = 0;

(NextSplit.first == StringRef::npos) {

ToNextSplitColumns = Token->getRemainingLength(LineIndex, TailOffset,

ContentStartColumn);

ToNextSplitColumns = Token->getRangeLength(

LineIndex, TailOffset,

.first +

.second + NextSplit.first, ContentStartColumn);

ToNextSplitColumns =

Token->getLengthAfterCompression(ToNextSplitColumns, Split);

LLVM_DEBUG(llvm::dbgs()

<<

<< ContentStartColumn <<

);

LLVM_DEBUG(llvm::dbgs()

<<

<< ToNextSplitColumns <<

);

ContinueOnLine =

ContentStartColumn + ToNextSplitColumns <= ColumnLimit;

ExcessCharactersPenalty = 0;

(!ContinueOnLine && !Strict) {

ExcessCharactersPenalty =

(ContentStartColumn + ToNextSplitColumns - ColumnLimit) *

LLVM_DEBUG(llvm::dbgs()

<<

<< ExcessCharactersPenalty

<<

<< NewBreakPenalty <<

);

(ExcessCharactersPenalty < NewBreakPenalty) {

ContinueOnLine =

;

(ContinueOnLine) {

LLVM_DEBUG(llvm::dbgs() <<

);

Token->compressWhitespace(LineIndex, TailOffset, Split,

ContentStartColumn += ToSplitColumns + 1;

Penalty += ExcessCharactersPenalty;

RemainingTokenColumns = Token->getRemainingLength(

LineIndex, TailOffset, ContentStartColumn);

LLVM_DEBUG(llvm::dbgs() <<

);

ContentIndent = Token->getContentIndent(LineIndex);

LLVM_DEBUG(llvm::dbgs()

<<

<< ContentIndent <<

);

ContentStartColumn = ContentIndent + Token->getContentStartColumn(

NewRemainingTokenColumns = Token->getRemainingLength(

LineIndex, TailOffset +

.first +

.second,

ContentStartColumn);

(NewRemainingTokenColumns == 0) {

ContentStartColumn =

Token->getContentStartColumn(LineIndex,

);

NewRemainingTokenColumns = Token->getRemainingLength(

LineIndex, TailOffset +

.first +

.second,

ContentStartColumn);

(NewRemainingTokenColumns >= RemainingTokenColumns) {

LLVM_DEBUG(llvm::dbgs() <<

<< TailOffset +

.first

<<

<<

.second <<

);

Token->insertBreak(LineIndex, TailOffset, Split, ContentIndent,

Penalty += NewBreakPenalty;

RemainingTokenColumns = NewRemainingTokenColumns;

BreakInserted =

;

NewBreakBefore =

;

(LineIndex + 1 != EndIndex) {

NextLineIndex = LineIndex + 1;

(NewBreakBefore) {

ContentStartColumn += RemainingTokenColumns + 1;

Token->getReflowSplit(NextLineIndex, CommentPragmasRegex);

LLVM_DEBUG(llvm::dbgs()

<<

<< ContentStartColumn

<<

);

(SplitBeforeNext.first != StringRef::npos) {

LLVM_DEBUG(llvm::dbgs() << SplitBeforeNext.first <<

<< SplitBeforeNext.second <<

);

TailOffset = SplitBeforeNext.first + SplitBeforeNext.second;

RemainingTokenColumns = Token->getRemainingLength(

NextLineIndex, TailOffset, ContentStartColumn);

(ContentStartColumn + RemainingTokenColumns > ColumnLimit) {

LLVM_DEBUG(llvm::dbgs()

<<

<< (ContentStartColumn + RemainingTokenColumns)

<<

<< ColumnLimit

<<

<< ContentStartColumn

<<

<< TailOffset <<

);

Token->getSplit(NextLineIndex, TailOffset, ColumnLimit,

ContentStartColumn, CommentPragmasRegex);

(

.first == StringRef::npos) {

LLVM_DEBUG(llvm::dbgs() <<

);

ToSplitColumns = Token->getRangeLength(

NextLineIndex, TailOffset,

.first, ContentStartColumn);

(ContentStartColumn + ToSplitColumns > ColumnLimit) {

LLVM_DEBUG(llvm::dbgs() <<

<< (ContentStartColumn + ToSplitColumns)

<<

<< ColumnLimit);

ExcessCharactersPenalty =

(ContentStartColumn + ToSplitColumns - ColumnLimit) *

(NewBreakPenalty < ExcessCharactersPenalty)

LLVM_DEBUG(llvm::dbgs() <<

);

ContentStartColumn =

Token->getContentStartColumn(NextLineIndex,

);

RemainingTokenColumns = Token->getRemainingLength(

NextLineIndex, TailOffset, ContentStartColumn);

Token->adaptStartOfLine(NextLineIndex, Whitespaces);

(NewBreakBefore) {

assert(Penalty >= NewBreakPenalty);

Penalty -= NewBreakPenalty;

Token->reflow(NextLineIndex, Whitespaces);

Token->getSplitAfterLastLine(TailOffset);

(SplitAfterLastLine.first != StringRef::npos) {

LLVM_DEBUG(llvm::dbgs() <<

);

(ContentStartColumn + RemainingTokenColumns - ColumnLimit);

Token->replaceWhitespaceAfterLastLine(TailOffset, SplitAfterLastLine,

ContentStartColumn =

Token->getContentStartColumn(Token->getLineCount() - 1,

);

RemainingTokenColumns = Token->getRemainingLength(

Token->getLineCount() - 1,

TailOffset + SplitAfterLastLine.first + SplitAfterLastLine.second,

ContentStartColumn);

State.Column = ContentStartColumn + RemainingTokenColumns -

Current.UnbreakableTailLength;

(BreakInserted) {

Token->updateAfterBroken(Whitespaces);

(Current.isNot(TT_LineComment))

(ParenState &

: State.Stack)

.BreakBeforeParameter =

;

(Current.is(TT_BlockComment))

State.NoContinuation =

;

State.Stack.back().LastSpace = StartColumn;

Token->updateNextToken(State);

{Penalty, Exceeded};

Style.

- (State.Line->InPPDirective ? 2 : 0);

ContinuationIndenter::nextIsMultilineString(

&State) {

(!Current.isStringLiteral() || Current.is(TT_ImplicitStringLiteral))

(Current.TokenText.starts_with(

))

(Current.IsMultiline)

(Current.getNextNonComment() &&

Current.getNextNonComment()->isStringLiteral()) {

State.Column + Current.ColumnWidth + Current.UnbreakableTailLength >

Declares BreakableToken, BreakableStringLiteral, BreakableComment, BreakableBlockComment and Breakabl...

This file implements an indenter that manages the indentation of continuations.

This file declares Format APIs to be used internally by the formatting library implementation.

This file contains the declaration of the FormatToken, a wrapper around Token with additional informa...

Various functions to configurably format source code.

Defines and computes precedence levels for binary/ternary operators.

Defines the SourceManager interface.

unsigned LongestObjCSelectorName

Defines the clang::TokenKind enum and support functions.

WhitespaceManager class manages whitespace around tokens and their replacements.

__DEVICE__ int max(int __a, int __b)

This class handles loading and caching of source files into memory.

unsigned getSpellingColumnNumber(SourceLocation Loc, bool *Invalid=nullptr) const

Token - This structure provides full information about a lexed token.

bool is(tok::TokenKind K) const

is/isNot - Predicates to check if this token is a specific kind, as in "if (Tok.is(tok::l_brace)) {....

std::pair< StringRef::size_type, unsigned > Split

Contains starting character index and length of split.

bool canBreak(const LineState &State)

Returns true, if a line break after State is allowed.

unsigned addTokenToState(LineState &State, bool Newline, bool DryRun, unsigned ExtraSpaces=0)

Appends the next token to State and updates information necessary for indentation.

unsigned getColumnLimit(const LineState &State) const

Get the column limit for this line.

LineState getInitialState(unsigned FirstIndent, unsigned FirstStartColumn, const AnnotatedLine *Line, bool DryRun)

Get the initial state, i.e.

ContinuationIndenter(const FormatStyle &Style, const AdditionalKeywords &Keywords, const SourceManager &SourceMgr, WhitespaceManager &Whitespaces, encoding::Encoding Encoding, bool BinPackInconclusiveFunctions)

Constructs a ContinuationIndenter to format Line starting in column FirstIndent.

bool mustBreak(const LineState &State)

Returns true, if a line break after State is mandatory.

Manages the whitespaces around tokens and their replacements.

llvm::Error addReplacement(const tooling::Replacement &Replacement)

void replaceWhitespace(FormatToken &Tok, unsigned Newlines, unsigned Spaces, unsigned StartOfTokenColumn, bool IsAligned=false, bool InPPDirective=false)

Replaces the whitespace in front of Tok.

unsigned columnWidthWithTabs(StringRef Text, unsigned StartColumn, unsigned TabWidth, Encoding Encoding)

Returns the number of columns required to display the Text, starting from the StartColumn on a termin...

std::pair< tooling::Replacements, unsigned > reformat(const FormatStyle &Style, StringRef Code, ArrayRef< tooling::Range > Ranges, unsigned FirstStartColumn, unsigned NextStartColumn, unsigned LastStartColumn, StringRef FileName, FormattingAttemptStatus *Status)

Reformats the given Ranges in the code fragment Code.

static bool mustBreakBinaryOperation(const FormatToken &Current, const FormatStyle &Style)

static unsigned getLastLineEndColumn(StringRef Text, unsigned StartColumn, unsigned TabWidth, encoding::Encoding Encoding)

static bool shouldUnindentNextOperator(const FormatToken &Tok)

FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language=FormatStyle::LanguageKind::LK_Cpp)

Returns a format style complying with the LLVM coding standards: http://llvm.org/docs/CodingStandards...

bool switchesFormatting(const FormatToken &Token)

Checks if Token switches formatting, like /* clang-format off *‍/.

static bool hasNestedBlockInlined(const FormatToken *Previous, const FormatToken &Current, const FormatStyle &Style)

static bool startsSegmentOfBuilderTypeCall(const FormatToken &Tok)

static unsigned getLengthToNextOperator(const FormatToken &Tok)

static bool isAlignableBinaryOperator(const FormatToken &Token)

static unsigned getLengthToMatchingParen(const FormatToken &Tok, ArrayRef< ParenState > Stack)

static bool shouldIndentWrappedSelectorName(const FormatStyle &Style, LineType LineType)

bool getPredefinedStyle(StringRef Name, FormatStyle::LanguageKind Language, FormatStyle *Style)

Gets a predefined style for the specified language by name.

static std::optional< StringRef > getRawStringDelimiter(StringRef TokenText)

static StringRef getCanonicalRawStringDelimiter(const FormatStyle &Style, FormatStyle::LanguageKind Language)

static bool startsNextOperand(const FormatToken &Current)

static bool opensProtoMessageField(const FormatToken &LessTok, const FormatStyle &Style)

static StringRef getEnclosingFunctionName(const FormatToken &Current)

@ LT_PreprocessorDirective

bool startsNextParameter(const FormatToken &Current, const FormatStyle &Style)

The JSON file list parser is used to communicate input to InstallAPI.

if(T->getSizeExpr()) TRY_TO(TraverseStmt(const_cast< Expr * >(T -> getSizeExpr())))

Language

The language for the input, used to select and validate the language standard and possible actions.

const FunctionProtoType * T

Encapsulates keywords that are context sensitive or for languages not properly supported by Clang's l...

bool isVerilogBegin(const FormatToken &Tok) const

Returns whether Tok is a Verilog keyword that opens a block.

bool isVerilogEndOfLabel(const FormatToken &Tok) const

IdentifierInfo * kw_import

IdentifierInfo * kw_dollar

IdentifierInfo * kw_async

IdentifierInfo * kw_await

IdentifierInfo * kw_implements

IdentifierInfo * kw_function

IdentifierInfo * kw_extends

bool BeforeLambdaBody

Wrap lambda block.

The FormatStyle is used to configure the formatting to follow specific guidelines.

@ UT_Never

Never use tab.

unsigned ContinuationIndentWidth

Indent width for line continuations.

bool AlwaysBreakBeforeMultilineStrings

This option is renamed to BreakAfterReturnType.

ReturnTypeBreakingStyle BreakAfterReturnType

The function declaration return type breaking style to use.

LanguageKind

Supported languages.

@ LK_Java

Should be used for Java.

@ LK_ObjC

Should be used for Objective-C, Objective-C++.

@ LK_Proto

Should be used for Protocol Buffers (https://developers.google.com/protocol-buffers/).

@ LK_TextProto

Should be used for Protocol Buffer messages in text format (https://developers.google....

bool Cpp11BracedListStyle

If true, format braced lists as best suited for C++11 braced lists.

BreakInheritanceListStyle BreakInheritanceList

The inheritance list style to use.

unsigned IndentWidth

The number of columns to use for indentation.

bool IndentRequiresClause

Indent the requires clause in a template.

std::vector< RawStringFormat > RawStringFormats

Defines hints for detecting supported languages code blocks in raw strings.

PPDirectiveIndentStyle IndentPPDirectives

The preprocessor directive indenting style to use.

@ BPPS_BinPack

Bin-pack parameters.

BinaryOperatorStyle BreakBeforeBinaryOperators

The way to wrap binary operators.

@ BPS_Auto

Automatically determine parameter bin-packing behavior.

@ BPS_Always

Always bin-pack parameters.

@ RCS_Never

Leave comments untouched.

@ BCIS_AfterColon

Break constructor initializers after the colon and commas.

@ BCIS_BeforeColon

Break constructor initializers before the colon and after the commas.

@ BCIS_BeforeComma

Break constructor initializers before the colon and commas, and align the commas with the colon.

BreakBeforeConceptDeclarationsStyle BreakBeforeConceptDeclarations

The concept declaration style to use.

BreakTemplateDeclarationsStyle BreakTemplateDeclarations

The template declaration breaking style to use.

@ BOS_None

Break after operators.

bool IndentWrappedFunctionNames

Indent if a function definition or declaration is wrapped after the type.

LanguageKind Language

Language, this format style is targeted at.

@ BAS_DontAlign

Don't align, instead use ContinuationIndentWidth, e.g.:

@ BAS_AlwaysBreak

Always break after an open bracket, if the parameters don't fit on a single line, e....

@ BAS_BlockIndent

Always break after an open bracket, if the parameters don't fit on a single line.

@ BBIAS_Always

Always break before inline ASM colon.

@ BBIAS_OnlyMultiline

Break before inline ASM colon if the line length is longer than column limit.

unsigned TabWidth

The number of columns used for tab stops.

@ PPDIS_AfterHash

Indents directives after the hash.

@ LBI_OuterScope

For statements within block scope, align lambda body relative to the indentation level of the outer s...

@ LBI_Signature

Align lambda body relative to the lambda signature.

unsigned PenaltyBreakFirstLessLess

The penalty for breaking before the first <<.

unsigned ObjCBlockIndentWidth

The number of characters to use for indentation of ObjC blocks.

std::optional< FormatStyle > GetLanguageStyle(LanguageKind Language) const

std::optional< unsigned > BracedInitializerIndentWidth

The number of columns to use to indent the contents of braced init lists.

bool ExperimentalAutoDetectBinPacking

If true, clang-format detects whether function calls and definitions are formatted with one parameter...

bool ObjCBreakBeforeNestedBlockParam

Break parameters list into lines when there is nested block parameters in a function call.

OperandAlignmentStyle AlignOperands

If true, horizontally align operands of binary and ternary expressions.

@ BTDS_No

Do not force break before declaration.

@ BTDS_Leave

Do not change the line breaking before the declaration.

BreakBinaryOperationsStyle BreakBinaryOperations

The break binary operations style to use.

BreakConstructorInitializersStyle BreakConstructorInitializers

The break constructor initializers style to use.

bool BreakStringLiterals

Allow breaking string literals when formatting.

@ PCIS_NextLineOnly

Put all constructor initializers on the next line if they fit.

@ PCIS_BinPack

Bin-pack constructor initializers.

@ PCIS_NextLine

Same as PCIS_CurrentLine except that if all constructor initializers do not fit on the current line,...

BraceBreakingStyle BreakBeforeBraces

The brace breaking style to use.

@ BILS_AfterColon

Break inheritance list after the colon and commas.

@ BILS_BeforeComma

Break inheritance list before the colon and commas, and align the commas with the colon.

unsigned PenaltyExcessCharacter

The penalty for each character outside of the column limit.

@ DAS_BreakElements

Break inside DAGArg after each list element but for the last.

unsigned ConstructorInitializerIndentWidth

This option is deprecated.

@ RCPS_OwnLineWithBrace

As with OwnLine, except, unless otherwise prohibited, place a following open brace (of a function def...

@ RCPS_OwnLine

Always put the requires clause on its own line (possibly followed by a semicolon).

@ RCPS_WithPreceding

Try to put the clause together with the preceding part of a declaration.

@ RCPS_SingleLine

Try to put everything in the same line if possible.

@ RCPS_WithFollowing

Try to put the requires clause together with the class or function declaration.

RequiresClausePositionStyle RequiresClausePosition

The position of the requires clause.

BreakBeforeInlineASMColonStyle BreakBeforeInlineASMColon

The inline ASM colon style to use.

@ BS_Whitesmiths

Like Allman but always indent braces and line up code with braces.

bool BinPackArguments

If false, a function call's arguments will either be all on the same line or will have one line each.

@ REI_Keyword

Align requires expression body relative to the requires keyword.

PackConstructorInitializersStyle PackConstructorInitializers

The pack constructor initializers style to use.

@ BBCDS_Allowed

Breaking between template declaration and concept is allowed.

@ BBCDS_Never

Keep the template declaration line together with concept.

@ BBCDS_Always

Always break before concept, putting it in the line after the template declaration.

ReflowCommentsStyle ReflowComments

Comment reformatting style.

bool AllowAllParametersOfDeclarationOnNextLine

This option is deprecated.

BracketAlignmentStyle AlignAfterOpenBracket

If true, horizontally aligns arguments after an open bracket.

BinPackParametersStyle BinPackParameters

The bin pack parameters style to use.

unsigned MaxEmptyLinesToKeep

The maximum number of consecutive empty lines to keep.

BinPackStyle ObjCBinPackProtocolList

Controls bin-packing Objective-C protocol conformance list items into as few lines as possible when t...

bool isJavaScript() const

DAGArgStyle TableGenBreakInsideDAGArg

The styles of the line break inside the DAGArg in TableGen.

LambdaBodyIndentationKind LambdaBodyIndentation

The indentation style of lambda bodies.

@ BBO_Never

Don't break binary operations.

BraceWrappingFlags BraceWrapping

Control of individual brace wrapping cases.

unsigned PenaltyBreakString

The penalty for each line break introduced inside a string literal.

RequiresExpressionIndentationKind RequiresExpressionIndentation

The indentation used for requires expression bodies.

unsigned PenaltyIndentedWhitespace

Penalty for each character of whitespace indentation (counted relative to leading non-whitespace colu...

bool AllowAllArgumentsOnNextLine

If a function call or braced initializer list doesn't fit on a line, allow putting all arguments onto...

unsigned PenaltyBreakComment

The penalty for each line break introduced inside a comment.

@ RTBS_ExceptShortType

Same as Automatic above, except that there is no break after short return types.

@ RTBS_None

This is deprecated. See Automatic below.

UseTabStyle UseTab

The way to use tab characters in the resulting file.

@ OAS_AlignAfterOperator

Horizontally align operands of binary and ternary expressions.

@ OAS_DontAlign

Do not align operands of binary and ternary expressions.

bool BreakBeforeTernaryOperators

If true, ternary operators will be placed after line breaks.

unsigned ColumnLimit

The column limit.

A wrapper around a Token storing information about the whitespace characters preceding it.

unsigned NestingLevel

The nesting level of this token, i.e.

bool isMemberAccess() const

Returns true if this is a "." or "->" accessing a member.

unsigned CanBreakBefore

true if it is allowed to break before this token.

StringRef TokenText

The raw text of the token.

FormatToken * getPreviousNonComment() const

Returns the previous token ignoring comments.

bool closesScope() const

Returns whether Tok is )]} or a closing > of a template or in protos.

bool is(tok::TokenKind Kind) const

unsigned TotalLength

The total length of the unwrapped line up to and including this token.

bool isTrailingComment() const

FormatToken * NextOperator

If this is an operator (or "."/"->") in a sequence of operators with the same precedence,...

FormatToken * MatchingParen

If this is a bracket, this points to the matching one.

FormatToken * Previous

The previous token in the unwrapped line.

The current state when indenting a unwrapped line.

llvm::StringMap< FormatStyle > EnclosingFunctionStyle

std::optional< FormatStyle > getDelimiterStyle(StringRef Delimiter) const

std::optional< FormatStyle > getEnclosingFunctionStyle(StringRef EnclosingFunction) const

RawStringFormatStyleManager(const FormatStyle &CodeStyle)

llvm::StringMap< FormatStyle > DelimiterStyle

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4