llvm-project
2848 строк · 122.3 Кб
1//===--- ContinuationIndenter.cpp - Format C++ code -----------------------===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8///9/// \file10/// This file implements the continuation indenter.11///12//===----------------------------------------------------------------------===//13// Returns true if a TT_SelectorName should be indented when wrapped,33// false otherwise.34static bool shouldIndentWrappedSelectorName(const FormatStyle &Style,35LineType LineType) {36return Style.IndentWrappedFunctionNames || LineType == LT_ObjCMethodDecl;37}38// Returns true if a binary operator following \p Tok should be unindented when40// the style permits it.41static bool shouldUnindentNextOperator(const FormatToken &Tok) {42const FormatToken *Previous = Tok.getPreviousNonComment();43return Previous && (Previous->getPrecedence() == prec::Assignment ||44Previous->isOneOf(tok::kw_return, TT_RequiresClause));45}46// Returns the length of everything up to the first possible line break after48// the ), ], } or > matching \c Tok.49static unsigned getLengthToMatchingParen(const FormatToken &Tok,50ArrayRef<ParenState> Stack) {51// Normally whether or not a break before T is possible is calculated and52// stored in T.CanBreakBefore. Braces, array initializers and text proto53// messages like `key: < ... >` are an exception: a break is possible54// before a closing brace R if a break was inserted after the corresponding55// opening brace. The information about whether or not a break is needed56// before a closing brace R is stored in the ParenState field57// S.BreakBeforeClosingBrace where S is the state that R closes.58//59// In order to decide whether there can be a break before encountered right60// braces, this implementation iterates over the sequence of tokens and over61// the paren stack in lockstep, keeping track of the stack level which visited62// right braces correspond to in MatchingStackIndex.63//64// For example, consider:65// L. <- line number66// 1. {67// 2. {1},68// 3. {2},69// 4. {{3}}}70// ^ where we call this method with this token.71// The paren stack at this point contains 3 brace levels:72// 0. { at line 1, BreakBeforeClosingBrace: true73// 1. first { at line 4, BreakBeforeClosingBrace: false74// 2. second { at line 4, BreakBeforeClosingBrace: false,75// where there might be fake parens levels in-between these levels.76// The algorithm will start at the first } on line 4, which is the matching77// brace of the initial left brace and at level 2 of the stack. Then,78// examining BreakBeforeClosingBrace: false at level 2, it will continue to79// the second } on line 4, and will traverse the stack downwards until it80// finds the matching { on level 1. Then, examining BreakBeforeClosingBrace:81// false at level 1, it will continue to the third } on line 4 and will82// traverse the stack downwards until it finds the matching { on level 0.83// Then, examining BreakBeforeClosingBrace: true at level 0, the algorithm84// will stop and will use the second } on line 4 to determine the length to85// return, as in this example the range will include the tokens: {3}}86//87// The algorithm will only traverse the stack if it encounters braces, array88// initializer squares or text proto angle brackets.89if (!Tok.MatchingParen)90return 0;91FormatToken *End = Tok.MatchingParen;92// Maintains a stack level corresponding to the current End token.93int MatchingStackIndex = Stack.size() - 1;94// Traverses the stack downwards, looking for the level to which LBrace95// corresponds. Returns either a pointer to the matching level or nullptr if96// LParen is not found in the initial portion of the stack up to97// MatchingStackIndex.98auto FindParenState = [&](const FormatToken *LBrace) -> const ParenState * {99while (MatchingStackIndex >= 0 && Stack[MatchingStackIndex].Tok != LBrace)100--MatchingStackIndex;101return MatchingStackIndex >= 0 ? &Stack[MatchingStackIndex] : nullptr;102};103for (; End->Next; End = End->Next) {104if (End->Next->CanBreakBefore)105break;106if (!End->Next->closesScope())107continue;108if (End->Next->MatchingParen &&109End->Next->MatchingParen->isOneOf(110tok::l_brace, TT_ArrayInitializerLSquare, tok::less)) {111const ParenState *State = FindParenState(End->Next->MatchingParen);112if (State && State->BreakBeforeClosingBrace)113break;114}115}116return End->TotalLength - Tok.TotalLength + 1;117}118}124// Returns \c true if \c Tok is the "." or "->" of a call and starts the next126// segment of a builder type call.127static bool startsSegmentOfBuilderTypeCall(const FormatToken &Tok) {128return Tok.isMemberAccess() && Tok.Previous && Tok.Previous->closesScope();129}130// Returns \c true if \c Current starts a new parameter.132static bool startsNextParameter(const FormatToken &Current,133const FormatStyle &Style) {134const FormatToken &Previous = *Current.Previous;135if (Current.is(TT_CtorInitializerComma) &&136Style.BreakConstructorInitializers == FormatStyle::BCIS_BeforeComma) {137return true;138}139if (Style.Language == FormatStyle::LK_Proto && Current.is(TT_SelectorName))140return true;141return Previous.is(tok::comma) && !Current.isTrailingComment() &&142((Previous.isNot(TT_CtorInitializerComma) ||143Style.BreakConstructorInitializers !=144FormatStyle::BCIS_BeforeComma) &&145(Previous.isNot(TT_InheritanceComma) ||146Style.BreakInheritanceList != FormatStyle::BILS_BeforeComma));147}148}158// Returns the delimiter of a raw string literal, or std::nullopt if TokenText160// is not the text of a raw string literal. The delimiter could be the empty161// string. For example, the delimiter of R"deli(cont)deli" is deli.162static std::optional<StringRef> getRawStringDelimiter(StringRef TokenText) {163if (TokenText.size() < 5 // The smallest raw string possible is 'R"()"'.164|| !TokenText.starts_with("R\"") || !TokenText.ends_with("\"")) {165return std::nullopt;166}167}184// Returns the canonical delimiter for \p Language, or the empty string if no186// canonical delimiter is specified.187static StringRef188getCanonicalRawStringDelimiter(const FormatStyle &Style,189FormatStyle::LanguageKind Language) {190for (const auto &Format : Style.RawStringFormats)191if (Format.Language == Language)192return StringRef(Format.CanonicalDelimiter);193return "";194}195}217}225}234}289}370}632}671}941}1208}1484}1496}1676}1787}1805}1968}2019}2047}2060}2208}2224}2278// Returns the enclosing function name of a token, or the empty string if not2280// found.2281static StringRef getEnclosingFunctionName(const FormatToken &Current) {2282// Look for: 'function(' or 'function<templates>(' before Current.2283auto Tok = Current.getPreviousNonComment();2284if (!Tok || Tok->isNot(tok::l_paren))2285return "";2286Tok = Tok->getPreviousNonComment();2287if (!Tok)2288return "";2289if (Tok->is(TT_TemplateCloser)) {2290Tok = Tok->MatchingParen;2291if (Tok)2292Tok = Tok->getPreviousNonComment();2293}2294if (!Tok || Tok->isNot(tok::identifier))2295return "";2296return Tok->TokenText;2297}2298}2317}2434}2818}2823}2846