| //===--- TokenAnnotator.cpp - Format C++ code -----------------------------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| /// |
| /// \file |
| /// This file implements a token annotator, i.e. creates |
| /// \c AnnotatedTokens out of \c FormatTokens with required extra information. |
| /// |
| //===----------------------------------------------------------------------===// |
| |
| #include "TokenAnnotator.h" |
| #include "FormatToken.h" |
| #include "clang/Basic/SourceManager.h" |
| #include "clang/Basic/TokenKinds.h" |
| #include "llvm/ADT/SmallPtrSet.h" |
| #include "llvm/Support/Debug.h" |
| |
| #define DEBUG_TYPE "format-token-annotator" |
| |
| namespace clang { |
| namespace format { |
| |
| namespace { |
| |
| /// Returns \c true if the token can be used as an identifier in |
| /// an Objective-C \c \@selector, \c false otherwise. |
| /// |
| /// Because getFormattingLangOpts() always lexes source code as |
| /// Objective-C++, C++ keywords like \c new and \c delete are |
| /// lexed as tok::kw_*, not tok::identifier, even for Objective-C. |
| /// |
| /// For Objective-C and Objective-C++, both identifiers and keywords |
| /// are valid inside @selector(...) (or a macro which |
| /// invokes @selector(...)). So, we allow treat any identifier or |
| /// keyword as a potential Objective-C selector component. |
| static bool canBeObjCSelectorComponent(const FormatToken &Tok) { |
| return Tok.Tok.getIdentifierInfo() != nullptr; |
| } |
| |
| /// With `Left` being '(', check if we're at either `[...](` or |
| /// `[...]<...>(`, where the [ opens a lambda capture list. |
| static bool isLambdaParameterList(const FormatToken *Left) { |
| // Skip <...> if present. |
| if (Left->Previous && Left->Previous->is(tok::greater) && |
| Left->Previous->MatchingParen && |
| Left->Previous->MatchingParen->is(TT_TemplateOpener)) |
| Left = Left->Previous->MatchingParen; |
| |
| // Check for `[...]`. |
| return Left->Previous && Left->Previous->is(tok::r_square) && |
| Left->Previous->MatchingParen && |
| Left->Previous->MatchingParen->is(TT_LambdaLSquare); |
| } |
| |
| /// Returns \c true if the token is followed by a boolean condition, \c false |
| /// otherwise. |
| static bool isKeywordWithCondition(const FormatToken &Tok) { |
| return Tok.isOneOf(tok::kw_if, tok::kw_for, tok::kw_while, tok::kw_switch, |
| tok::kw_constexpr, tok::kw_catch); |
| } |
| |
| /// A parser that gathers additional information about tokens. |
| /// |
| /// The \c TokenAnnotator tries to match parenthesis and square brakets and |
| /// store a parenthesis levels. It also tries to resolve matching "<" and ">" |
| /// into template parameter lists. |
| class AnnotatingParser { |
| public: |
| AnnotatingParser(const FormatStyle &Style, AnnotatedLine &Line, |
| const AdditionalKeywords &Keywords) |
| : Style(Style), Line(Line), CurrentToken(Line.First), AutoFound(false), |
| Keywords(Keywords) { |
| Contexts.push_back(Context(tok::unknown, 1, /*IsExpression=*/false)); |
| resetTokenMetadata(CurrentToken); |
| } |
| |
| private: |
| bool parseAngle() { |
| if (!CurrentToken || !CurrentToken->Previous) |
| return false; |
| if (NonTemplateLess.count(CurrentToken->Previous)) |
| return false; |
| |
| const FormatToken &Previous = *CurrentToken->Previous; // The '<'. |
| if (Previous.Previous) { |
| if (Previous.Previous->Tok.isLiteral()) |
| return false; |
| if (Previous.Previous->is(tok::r_paren) && Contexts.size() > 1 && |
| (!Previous.Previous->MatchingParen || |
| !Previous.Previous->MatchingParen->is(TT_OverloadedOperatorLParen))) |
| return false; |
| } |
| |
| FormatToken *Left = CurrentToken->Previous; |
| Left->ParentBracket = Contexts.back().ContextKind; |
| ScopedContextCreator ContextCreator(*this, tok::less, 12); |
| |
| // If this angle is in the context of an expression, we need to be more |
| // hesitant to detect it as opening template parameters. |
| bool InExprContext = Contexts.back().IsExpression; |
| |
| Contexts.back().IsExpression = false; |
| // If there's a template keyword before the opening angle bracket, this is a |
| // template parameter, not an argument. |
| Contexts.back().InTemplateArgument = |
| Left->Previous && Left->Previous->Tok.isNot(tok::kw_template); |
| |
| if (Style.Language == FormatStyle::LK_Java && |
| CurrentToken->is(tok::question)) |
| next(); |
| |
| while (CurrentToken) { |
| if (CurrentToken->is(tok::greater)) { |
| // Try to do a better job at looking for ">>" within the condition of |
| // a statement. Conservatively insert spaces between consecutive ">" |
| // tokens to prevent splitting right bitshift operators and potentially |
| // altering program semantics. This check is overly conservative and |
| // will prevent spaces from being inserted in select nested template |
| // parameter cases, but should not alter program semantics. |
| if (CurrentToken->Next && CurrentToken->Next->is(tok::greater) && |
| Left->ParentBracket != tok::less && |
| (isKeywordWithCondition(*Line.First) || |
| CurrentToken->getStartOfNonWhitespace() == |
| CurrentToken->Next->getStartOfNonWhitespace().getLocWithOffset( |
| -1))) |
| return false; |
| Left->MatchingParen = CurrentToken; |
| CurrentToken->MatchingParen = Left; |
| // In TT_Proto, we must distignuish between: |
| // map<key, value> |
| // msg < item: data > |
| // msg: < item: data > |
| // In TT_TextProto, map<key, value> does not occur. |
| if (Style.Language == FormatStyle::LK_TextProto || |
| (Style.Language == FormatStyle::LK_Proto && Left->Previous && |
| Left->Previous->isOneOf(TT_SelectorName, TT_DictLiteral))) |
| CurrentToken->setType(TT_DictLiteral); |
| else |
| CurrentToken->setType(TT_TemplateCloser); |
| next(); |
| return true; |
| } |
| if (CurrentToken->is(tok::question) && |
| Style.Language == FormatStyle::LK_Java) { |
| next(); |
| continue; |
| } |
| if (CurrentToken->isOneOf(tok::r_paren, tok::r_square, tok::r_brace) || |
| (CurrentToken->isOneOf(tok::colon, tok::question) && InExprContext && |
| !Style.isCSharp() && Style.Language != FormatStyle::LK_Proto && |
| Style.Language != FormatStyle::LK_TextProto)) |
| return false; |
| // If a && or || is found and interpreted as a binary operator, this set |
| // of angles is likely part of something like "a < b && c > d". If the |
| // angles are inside an expression, the ||/&& might also be a binary |
| // operator that was misinterpreted because we are parsing template |
| // parameters. |
| // FIXME: This is getting out of hand, write a decent parser. |
| if (CurrentToken->Previous->isOneOf(tok::pipepipe, tok::ampamp) && |
| CurrentToken->Previous->is(TT_BinaryOperator) && |
| Contexts[Contexts.size() - 2].IsExpression && |
| !Line.startsWith(tok::kw_template)) |
| return false; |
| updateParameterCount(Left, CurrentToken); |
| if (Style.Language == FormatStyle::LK_Proto) { |
| if (FormatToken *Previous = CurrentToken->getPreviousNonComment()) { |
| if (CurrentToken->is(tok::colon) || |
| (CurrentToken->isOneOf(tok::l_brace, tok::less) && |
| Previous->isNot(tok::colon))) |
| Previous->setType(TT_SelectorName); |
| } |
| } |
| if (!consumeToken()) |
| return false; |
| } |
| return false; |
| } |
| |
| bool parseUntouchableParens() { |
| while (CurrentToken) { |
| CurrentToken->Finalized = true; |
| switch (CurrentToken->Tok.getKind()) { |
| case tok::l_paren: |
| next(); |
| if (!parseUntouchableParens()) |
| return false; |
| continue; |
| case tok::r_paren: |
| next(); |
| return true; |
| default: |
| // no-op |
| break; |
| } |
| next(); |
| } |
| return false; |
| } |
| |
| bool parseParens(bool LookForDecls = false) { |
| if (!CurrentToken) |
| return false; |
| FormatToken *Left = CurrentToken->Previous; |
| assert(Left && "Unknown previous token"); |
| FormatToken *PrevNonComment = Left->getPreviousNonComment(); |
| Left->ParentBracket = Contexts.back().ContextKind; |
| ScopedContextCreator ContextCreator(*this, tok::l_paren, 1); |
| |
| // FIXME: This is a bit of a hack. Do better. |
| Contexts.back().ColonIsForRangeExpr = |
| Contexts.size() == 2 && Contexts[0].ColonIsForRangeExpr; |
| |
| if (Left->Previous && Left->Previous->is(TT_UntouchableMacroFunc)) { |
| Left->Finalized = true; |
| return parseUntouchableParens(); |
| } |
| |
| bool StartsObjCMethodExpr = false; |
| if (FormatToken *MaybeSel = Left->Previous) { |
| // @selector( starts a selector. |
| if (MaybeSel->isObjCAtKeyword(tok::objc_selector) && MaybeSel->Previous && |
| MaybeSel->Previous->is(tok::at)) { |
| StartsObjCMethodExpr = true; |
| } |
| } |
| |
| if (Left->is(TT_OverloadedOperatorLParen)) { |
| // Find the previous kw_operator token. |
| FormatToken *Prev = Left; |
| while (!Prev->is(tok::kw_operator)) { |
| Prev = Prev->Previous; |
| assert(Prev && "Expect a kw_operator prior to the OperatorLParen!"); |
| } |
| |
| // If faced with "a.operator*(argument)" or "a->operator*(argument)", |
| // i.e. the operator is called as a member function, |
| // then the argument must be an expression. |
| bool OperatorCalledAsMemberFunction = |
| Prev->Previous && Prev->Previous->isOneOf(tok::period, tok::arrow); |
| Contexts.back().IsExpression = OperatorCalledAsMemberFunction; |
| } else if (Style.Language == FormatStyle::LK_JavaScript && |
| (Line.startsWith(Keywords.kw_type, tok::identifier) || |
| Line.startsWith(tok::kw_export, Keywords.kw_type, |
| tok::identifier))) { |
| // type X = (...); |
| // export type X = (...); |
| Contexts.back().IsExpression = false; |
| } else if (Left->Previous && |
| (Left->Previous->isOneOf(tok::kw_static_assert, tok::kw_while, |
| tok::l_paren, tok::comma) || |
| Left->Previous->isIf() || |
| Left->Previous->is(TT_BinaryOperator))) { |
| // static_assert, if and while usually contain expressions. |
| Contexts.back().IsExpression = true; |
| } else if (Style.Language == FormatStyle::LK_JavaScript && Left->Previous && |
| (Left->Previous->is(Keywords.kw_function) || |
| (Left->Previous->endsSequence(tok::identifier, |
| Keywords.kw_function)))) { |
| // function(...) or function f(...) |
| Contexts.back().IsExpression = false; |
| } else if (Style.Language == FormatStyle::LK_JavaScript && Left->Previous && |
| Left->Previous->is(TT_JsTypeColon)) { |
| // let x: (SomeType); |
| Contexts.back().IsExpression = false; |
| } else if (isLambdaParameterList(Left)) { |
| // This is a parameter list of a lambda expression. |
| Contexts.back().IsExpression = false; |
| } else if (Line.InPPDirective && |
| (!Left->Previous || !Left->Previous->is(tok::identifier))) { |
| Contexts.back().IsExpression = true; |
| } else if (Contexts[Contexts.size() - 2].CaretFound) { |
| // This is the parameter list of an ObjC block. |
| Contexts.back().IsExpression = false; |
| } else if (Left->Previous && Left->Previous->is(TT_ForEachMacro)) { |
| // The first argument to a foreach macro is a declaration. |
| Contexts.back().IsForEachMacro = true; |
| Contexts.back().IsExpression = false; |
| } else if (Left->Previous && Left->Previous->MatchingParen && |
| Left->Previous->MatchingParen->is(TT_ObjCBlockLParen)) { |
| Contexts.back().IsExpression = false; |
| } else if (!Line.MustBeDeclaration && !Line.InPPDirective) { |
| bool IsForOrCatch = |
| Left->Previous && Left->Previous->isOneOf(tok::kw_for, tok::kw_catch); |
| Contexts.back().IsExpression = !IsForOrCatch; |
| } |
| |
| // Infer the role of the l_paren based on the previous token if we haven't |
| // detected one one yet. |
| if (PrevNonComment && Left->is(TT_Unknown)) { |
| if (PrevNonComment->is(tok::kw___attribute)) { |
| Left->setType(TT_AttributeParen); |
| } else if (PrevNonComment->isOneOf(TT_TypenameMacro, tok::kw_decltype, |
| tok::kw_typeof, tok::kw__Atomic, |
| tok::kw___underlying_type)) { |
| Left->setType(TT_TypeDeclarationParen); |
| // decltype() and typeof() usually contain expressions. |
| if (PrevNonComment->isOneOf(tok::kw_decltype, tok::kw_typeof)) |
| Contexts.back().IsExpression = true; |
| } |
| } |
| |
| if (StartsObjCMethodExpr) { |
| Contexts.back().ColonIsObjCMethodExpr = true; |
| Left->setType(TT_ObjCMethodExpr); |
| } |
| |
| // MightBeFunctionType and ProbablyFunctionType are used for |
| // function pointer and reference types as well as Objective-C |
| // block types: |
| // |
| // void (*FunctionPointer)(void); |
| // void (&FunctionReference)(void); |
| // void (&&FunctionReference)(void); |
| // void (^ObjCBlock)(void); |
| bool MightBeFunctionType = !Contexts[Contexts.size() - 2].IsExpression; |
| bool ProbablyFunctionType = |
| CurrentToken->isOneOf(tok::star, tok::amp, tok::ampamp, tok::caret); |
| bool HasMultipleLines = false; |
| bool HasMultipleParametersOnALine = false; |
| bool MightBeObjCForRangeLoop = |
| Left->Previous && Left->Previous->is(tok::kw_for); |
| FormatToken *PossibleObjCForInToken = nullptr; |
| while (CurrentToken) { |
| // LookForDecls is set when "if (" has been seen. Check for |
| // 'identifier' '*' 'identifier' followed by not '=' -- this |
| // '*' has to be a binary operator but determineStarAmpUsage() will |
| // categorize it as an unary operator, so set the right type here. |
| if (LookForDecls && CurrentToken->Next) { |
| FormatToken *Prev = CurrentToken->getPreviousNonComment(); |
| if (Prev) { |
| FormatToken *PrevPrev = Prev->getPreviousNonComment(); |
| FormatToken *Next = CurrentToken->Next; |
| if (PrevPrev && PrevPrev->is(tok::identifier) && |
| Prev->isOneOf(tok::star, tok::amp, tok::ampamp) && |
| CurrentToken->is(tok::identifier) && Next->isNot(tok::equal)) { |
| Prev->setType(TT_BinaryOperator); |
| LookForDecls = false; |
| } |
| } |
| } |
| |
| if (CurrentToken->Previous->is(TT_PointerOrReference) && |
| CurrentToken->Previous->Previous->isOneOf(tok::l_paren, |
| tok::coloncolon)) |
| ProbablyFunctionType = true; |
| if (CurrentToken->is(tok::comma)) |
| MightBeFunctionType = false; |
| if (CurrentToken->Previous->is(TT_BinaryOperator)) |
| Contexts.back().IsExpression = true; |
| if (CurrentToken->is(tok::r_paren)) { |
| if (MightBeFunctionType && ProbablyFunctionType && CurrentToken->Next && |
| (CurrentToken->Next->is(tok::l_paren) || |
| (CurrentToken->Next->is(tok::l_square) && Line.MustBeDeclaration))) |
| Left->setType(Left->Next->is(tok::caret) ? TT_ObjCBlockLParen |
| : TT_FunctionTypeLParen); |
| Left->MatchingParen = CurrentToken; |
| CurrentToken->MatchingParen = Left; |
| |
| if (CurrentToken->Next && CurrentToken->Next->is(tok::l_brace) && |
| Left->Previous && Left->Previous->is(tok::l_paren)) { |
| // Detect the case where macros are used to generate lambdas or |
| // function bodies, e.g.: |
| // auto my_lambda = MACRO((Type *type, int i) { .. body .. }); |
| for (FormatToken *Tok = Left; Tok != CurrentToken; Tok = Tok->Next) { |
| if (Tok->is(TT_BinaryOperator) && |
| Tok->isOneOf(tok::star, tok::amp, tok::ampamp)) |
| Tok->setType(TT_PointerOrReference); |
| } |
| } |
| |
| if (StartsObjCMethodExpr) { |
| CurrentToken->setType(TT_ObjCMethodExpr); |
| if (Contexts.back().FirstObjCSelectorName) { |
| Contexts.back().FirstObjCSelectorName->LongestObjCSelectorName = |
| Contexts.back().LongestObjCSelectorName; |
| } |
| } |
| |
| if (Left->is(TT_AttributeParen)) |
| CurrentToken->setType(TT_AttributeParen); |
| if (Left->is(TT_TypeDeclarationParen)) |
| CurrentToken->setType(TT_TypeDeclarationParen); |
| if (Left->Previous && Left->Previous->is(TT_JavaAnnotation)) |
| CurrentToken->setType(TT_JavaAnnotation); |
| if (Left->Previous && Left->Previous->is(TT_LeadingJavaAnnotation)) |
| CurrentToken->setType(TT_LeadingJavaAnnotation); |
| if (Left->Previous && Left->Previous->is(TT_AttributeSquare)) |
| CurrentToken->setType(TT_AttributeSquare); |
| |
| if (!HasMultipleLines) |
| Left->setPackingKind(PPK_Inconclusive); |
| else if (HasMultipleParametersOnALine) |
| Left->setPackingKind(PPK_BinPacked); |
| else |
| Left->setPackingKind(PPK_OnePerLine); |
| |
| next(); |
| return true; |
| } |
| if (CurrentToken->isOneOf(tok::r_square, tok::r_brace)) |
| return false; |
| |
| if (CurrentToken->is(tok::l_brace)) |
| Left->setType(TT_Unknown); // Not TT_ObjCBlockLParen |
| if (CurrentToken->is(tok::comma) && CurrentToken->Next && |
| !CurrentToken->Next->HasUnescapedNewline && |
| !CurrentToken->Next->isTrailingComment()) |
| HasMultipleParametersOnALine = true; |
| bool ProbablyFunctionTypeLParen = |
| (CurrentToken->is(tok::l_paren) && CurrentToken->Next && |
| CurrentToken->Next->isOneOf(tok::star, tok::amp, tok::caret)); |
| if ((CurrentToken->Previous->isOneOf(tok::kw_const, tok::kw_auto) || |
| CurrentToken->Previous->isSimpleTypeSpecifier()) && |
| !(CurrentToken->is(tok::l_brace) || |
| (CurrentToken->is(tok::l_paren) && !ProbablyFunctionTypeLParen))) |
| Contexts.back().IsExpression = false; |
| if (CurrentToken->isOneOf(tok::semi, tok::colon)) { |
| MightBeObjCForRangeLoop = false; |
| if (PossibleObjCForInToken) { |
| PossibleObjCForInToken->setType(TT_Unknown); |
| PossibleObjCForInToken = nullptr; |
| } |
| } |
| if (MightBeObjCForRangeLoop && CurrentToken->is(Keywords.kw_in)) { |
| PossibleObjCForInToken = CurrentToken; |
| PossibleObjCForInToken->setType(TT_ObjCForIn); |
| } |
| // When we discover a 'new', we set CanBeExpression to 'false' in order to |
| // parse the type correctly. Reset that after a comma. |
| if (CurrentToken->is(tok::comma)) |
| Contexts.back().CanBeExpression = true; |
| |
| FormatToken *Tok = CurrentToken; |
| if (!consumeToken()) |
| return false; |
| updateParameterCount(Left, Tok); |
| if (CurrentToken && CurrentToken->HasUnescapedNewline) |
| HasMultipleLines = true; |
| } |
| return false; |
| } |
| |
| bool isCSharpAttributeSpecifier(const FormatToken &Tok) { |
| if (!Style.isCSharp()) |
| return false; |
| |
| // `identifier[i]` is not an attribute. |
| if (Tok.Previous && Tok.Previous->is(tok::identifier)) |
| return false; |
| |
| // Chains of [] in `identifier[i][j][k]` are not attributes. |
| if (Tok.Previous && Tok.Previous->is(tok::r_square)) { |
| auto *MatchingParen = Tok.Previous->MatchingParen; |
| if (!MatchingParen || MatchingParen->is(TT_ArraySubscriptLSquare)) |
| return false; |
| } |
| |
| const FormatToken *AttrTok = Tok.Next; |
| if (!AttrTok) |
| return false; |
| |
| // Just an empty declaration e.g. string []. |
| if (AttrTok->is(tok::r_square)) |
| return false; |
| |
| // Move along the tokens inbetween the '[' and ']' e.g. [STAThread]. |
| while (AttrTok && AttrTok->isNot(tok::r_square)) { |
| AttrTok = AttrTok->Next; |
| } |
| |
| if (!AttrTok) |
| return false; |
| |
| // Allow an attribute to be the only content of a file. |
| AttrTok = AttrTok->Next; |
| if (!AttrTok) |
| return true; |
| |
| // Limit this to being an access modifier that follows. |
| if (AttrTok->isOneOf(tok::kw_public, tok::kw_private, tok::kw_protected, |
| tok::comment, tok::kw_class, tok::kw_static, |
| tok::l_square, Keywords.kw_internal)) { |
| return true; |
| } |
| |
| // incase its a [XXX] retval func(.... |
| if (AttrTok->Next && |
| AttrTok->Next->startsSequence(tok::identifier, tok::l_paren)) |
| return true; |
| |
| return false; |
| } |
| |
| bool isCpp11AttributeSpecifier(const FormatToken &Tok) { |
| if (!Style.isCpp() || !Tok.startsSequence(tok::l_square, tok::l_square)) |
| return false; |
| // The first square bracket is part of an ObjC array literal |
| if (Tok.Previous && Tok.Previous->is(tok::at)) { |
| return false; |
| } |
| const FormatToken *AttrTok = Tok.Next->Next; |
| if (!AttrTok) |
| return false; |
| // C++17 '[[using ns: foo, bar(baz, blech)]]' |
| // We assume nobody will name an ObjC variable 'using'. |
| if (AttrTok->startsSequence(tok::kw_using, tok::identifier, tok::colon)) |
| return true; |
| if (AttrTok->isNot(tok::identifier)) |
| return false; |
| while (AttrTok && !AttrTok->startsSequence(tok::r_square, tok::r_square)) { |
| // ObjC message send. We assume nobody will use : in a C++11 attribute |
| // specifier parameter, although this is technically valid: |
| // [[foo(:)]]. |
| if (AttrTok->is(tok::colon) || |
| AttrTok->startsSequence(tok::identifier, tok::identifier) || |
| AttrTok->startsSequence(tok::r_paren, tok::identifier)) |
| return false; |
| if (AttrTok->is(tok::ellipsis)) |
| return true; |
| AttrTok = AttrTok->Next; |
| } |
| return AttrTok && AttrTok->startsSequence(tok::r_square, tok::r_square); |
| } |
| |
| bool parseSquare() { |
| if (!CurrentToken) |
| return false; |
| |
| // A '[' could be an index subscript (after an identifier or after |
| // ')' or ']'), it could be the start of an Objective-C method |
| // expression, it could the start of an Objective-C array literal, |
| // or it could be a C++ attribute specifier [[foo::bar]]. |
| FormatToken *Left = CurrentToken->Previous; |
| Left->ParentBracket = Contexts.back().ContextKind; |
| FormatToken *Parent = Left->getPreviousNonComment(); |
| |
| // Cases where '>' is followed by '['. |
| // In C++, this can happen either in array of templates (foo<int>[10]) |
| // or when array is a nested template type (unique_ptr<type1<type2>[]>). |
| bool CppArrayTemplates = |
| Style.isCpp() && Parent && Parent->is(TT_TemplateCloser) && |
| (Contexts.back().CanBeExpression || Contexts.back().IsExpression || |
| Contexts.back().InTemplateArgument); |
| |
| bool IsCpp11AttributeSpecifier = isCpp11AttributeSpecifier(*Left) || |
| Contexts.back().InCpp11AttributeSpecifier; |
| |
| // Treat C# Attributes [STAThread] much like C++ attributes [[...]]. |
| bool IsCSharpAttributeSpecifier = |
| isCSharpAttributeSpecifier(*Left) || |
| Contexts.back().InCSharpAttributeSpecifier; |
| |
| bool InsideInlineASM = Line.startsWith(tok::kw_asm); |
| bool IsCppStructuredBinding = Left->isCppStructuredBinding(Style); |
| bool StartsObjCMethodExpr = |
| !IsCppStructuredBinding && !InsideInlineASM && !CppArrayTemplates && |
| Style.isCpp() && !IsCpp11AttributeSpecifier && |
| !IsCSharpAttributeSpecifier && Contexts.back().CanBeExpression && |
| Left->isNot(TT_LambdaLSquare) && |
| !CurrentToken->isOneOf(tok::l_brace, tok::r_square) && |
| (!Parent || |
| Parent->isOneOf(tok::colon, tok::l_square, tok::l_paren, |
| tok::kw_return, tok::kw_throw) || |
| Parent->isUnaryOperator() || |
| // FIXME(bug 36976): ObjC return types shouldn't use TT_CastRParen. |
| Parent->isOneOf(TT_ObjCForIn, TT_CastRParen) || |
| (getBinOpPrecedence(Parent->Tok.getKind(), true, true) > |
| prec::Unknown)); |
| bool ColonFound = false; |
| |
| unsigned BindingIncrease = 1; |
| if (IsCppStructuredBinding) { |
| Left->setType(TT_StructuredBindingLSquare); |
| } else if (Left->is(TT_Unknown)) { |
| if (StartsObjCMethodExpr) { |
| Left->setType(TT_ObjCMethodExpr); |
| } else if (InsideInlineASM) { |
| Left->setType(TT_InlineASMSymbolicNameLSquare); |
| } else if (IsCpp11AttributeSpecifier) { |
| Left->setType(TT_AttributeSquare); |
| } else if (Style.Language == FormatStyle::LK_JavaScript && Parent && |
| Contexts.back().ContextKind == tok::l_brace && |
| Parent->isOneOf(tok::l_brace, tok::comma)) { |
| Left->setType(TT_JsComputedPropertyName); |
| } else if (Style.isCpp() && Contexts.back().ContextKind == tok::l_brace && |
| Parent && Parent->isOneOf(tok::l_brace, tok::comma)) { |
| Left->setType(TT_DesignatedInitializerLSquare); |
| } else if (IsCSharpAttributeSpecifier) { |
| Left->setType(TT_AttributeSquare); |
| } else if (CurrentToken->is(tok::r_square) && Parent && |
| Parent->is(TT_TemplateCloser)) { |
| Left->setType(TT_ArraySubscriptLSquare); |
| } else if (Style.Language == FormatStyle::LK_Proto || |
| Style.Language == FormatStyle::LK_TextProto) { |
| // Square braces in LK_Proto can either be message field attributes: |
| // |
| // optional Aaa aaa = 1 [ |
| // (aaa) = aaa |
| // ]; |
| // |
| // extensions 123 [ |
| // (aaa) = aaa |
| // ]; |
| // |
| // or text proto extensions (in options): |
| // |
| // option (Aaa.options) = { |
| // [type.type/type] { |
| // key: value |
| // } |
| // } |
| // |
| // or repeated fields (in options): |
| // |
| // option (Aaa.options) = { |
| // keys: [ 1, 2, 3 ] |
| // } |
| // |
| // In the first and the third case we want to spread the contents inside |
| // the square braces; in the second we want to keep them inline. |
| Left->setType(TT_ArrayInitializerLSquare); |
| if (!Left->endsSequence(tok::l_square, tok::numeric_constant, |
| tok::equal) && |
| !Left->endsSequence(tok::l_square, tok::numeric_constant, |
| tok::identifier) && |
| !Left->endsSequence(tok::l_square, tok::colon, TT_SelectorName)) { |
| Left->setType(TT_ProtoExtensionLSquare); |
| BindingIncrease = 10; |
| } |
| } else if (!CppArrayTemplates && Parent && |
| Parent->isOneOf(TT_BinaryOperator, TT_TemplateCloser, tok::at, |
| tok::comma, tok::l_paren, tok::l_square, |
| tok::question, tok::colon, tok::kw_return, |
| // Should only be relevant to JavaScript: |
| tok::kw_default)) { |
| Left->setType(TT_ArrayInitializerLSquare); |
| } else { |
| BindingIncrease = 10; |
| Left->setType(TT_ArraySubscriptLSquare); |
| } |
| } |
| |
| ScopedContextCreator ContextCreator(*this, tok::l_square, BindingIncrease); |
| Contexts.back().IsExpression = true; |
| if (Style.Language == FormatStyle::LK_JavaScript && Parent && |
| Parent->is(TT_JsTypeColon)) |
| Contexts.back().IsExpression = false; |
| |
| Contexts.back().ColonIsObjCMethodExpr = StartsObjCMethodExpr; |
| Contexts.back().InCpp11AttributeSpecifier = IsCpp11AttributeSpecifier; |
| Contexts.back().InCSharpAttributeSpecifier = IsCSharpAttributeSpecifier; |
| |
| while (CurrentToken) { |
| if (CurrentToken->is(tok::r_square)) { |
| if (IsCpp11AttributeSpecifier) |
| CurrentToken->setType(TT_AttributeSquare); |
| if (IsCSharpAttributeSpecifier) |
| CurrentToken->setType(TT_AttributeSquare); |
| else if (((CurrentToken->Next && |
| CurrentToken->Next->is(tok::l_paren)) || |
| (CurrentToken->Previous && |
| CurrentToken->Previous->Previous == Left)) && |
| Left->is(TT_ObjCMethodExpr)) { |
| // An ObjC method call is rarely followed by an open parenthesis. It |
| // also can't be composed of just one token, unless it's a macro that |
| // will be expanded to more tokens. |
| // FIXME: Do we incorrectly label ":" with this? |
| StartsObjCMethodExpr = false; |
| Left->setType(TT_Unknown); |
| } |
| if (StartsObjCMethodExpr && CurrentToken->Previous != Left) { |
| CurrentToken->setType(TT_ObjCMethodExpr); |
| // If we haven't seen a colon yet, make sure the last identifier |
| // before the r_square is tagged as a selector name component. |
| if (!ColonFound && CurrentToken->Previous && |
| CurrentToken->Previous->is(TT_Unknown) && |
| canBeObjCSelectorComponent(*CurrentToken->Previous)) |
| CurrentToken->Previous->setType(TT_SelectorName); |
| // determineStarAmpUsage() thinks that '*' '[' is allocating an |
| // array of pointers, but if '[' starts a selector then '*' is a |
| // binary operator. |
| if (Parent && Parent->is(TT_PointerOrReference)) |
| Parent->setType(TT_BinaryOperator); |
| } |
| // An arrow after an ObjC method expression is not a lambda arrow. |
| if (CurrentToken->getType() == TT_ObjCMethodExpr && |
| CurrentToken->Next && CurrentToken->Next->is(TT_LambdaArrow)) |
| CurrentToken->Next->setType(TT_Unknown); |
| Left->MatchingParen = CurrentToken; |
| CurrentToken->MatchingParen = Left; |
| // FirstObjCSelectorName is set when a colon is found. This does |
| // not work, however, when the method has no parameters. |
| // Here, we set FirstObjCSelectorName when the end of the method call is |
| // reached, in case it was not set already. |
| if (!Contexts.back().FirstObjCSelectorName) { |
| FormatToken *Previous = CurrentToken->getPreviousNonComment(); |
| if (Previous && Previous->is(TT_SelectorName)) { |
| Previous->ObjCSelectorNameParts = 1; |
| Contexts.back().FirstObjCSelectorName = Previous; |
| } |
| } else { |
| Left->ParameterCount = |
| Contexts.back().FirstObjCSelectorName->ObjCSelectorNameParts; |
| } |
| if (Contexts.back().FirstObjCSelectorName) { |
| Contexts.back().FirstObjCSelectorName->LongestObjCSelectorName = |
| Contexts.back().LongestObjCSelectorName; |
| if (Left->BlockParameterCount > 1) |
| Contexts.back().FirstObjCSelectorName->LongestObjCSelectorName = 0; |
| } |
| next(); |
| return true; |
| } |
| if (CurrentToken->isOneOf(tok::r_paren, tok::r_brace)) |
| return false; |
| if (CurrentToken->is(tok::colon)) { |
| if (IsCpp11AttributeSpecifier && |
| CurrentToken->endsSequence(tok::colon, tok::identifier, |
| tok::kw_using)) { |
| // Remember that this is a [[using ns: foo]] C++ attribute, so we |
| // don't add a space before the colon (unlike other colons). |
| CurrentToken->setType(TT_AttributeColon); |
| } else if (Left->isOneOf(TT_ArraySubscriptLSquare, |
| TT_DesignatedInitializerLSquare)) { |
| Left->setType(TT_ObjCMethodExpr); |
| StartsObjCMethodExpr = true; |
| Contexts.back().ColonIsObjCMethodExpr = true; |
| if (Parent && Parent->is(tok::r_paren)) |
| // FIXME(bug 36976): ObjC return types shouldn't use TT_CastRParen. |
| Parent->setType(TT_CastRParen); |
| } |
| ColonFound = true; |
| } |
| if (CurrentToken->is(tok::comma) && Left->is(TT_ObjCMethodExpr) && |
| !ColonFound) |
| Left->setType(TT_ArrayInitializerLSquare); |
| FormatToken *Tok = CurrentToken; |
| if (!consumeToken()) |
| return false; |
| updateParameterCount(Left, Tok); |
| } |
| return false; |
| } |
| |
| bool couldBeInStructArrayInitializer() const { |
| if (Contexts.size() < 2) |
| return false; |
| // We want to back up no more then 2 context levels i.e. |
| // . { { <- |
| const auto End = std::next(Contexts.rbegin(), 2); |
| auto Last = Contexts.rbegin(); |
| unsigned Depth = 0; |
| for (; Last != End; ++Last) { |
| if (Last->ContextKind == tok::l_brace) |
| ++Depth; |
| } |
| return Depth == 2 && Last->ContextKind != tok::l_brace; |
| } |
| |
| bool parseBrace() { |
| if (CurrentToken) { |
| FormatToken *Left = CurrentToken->Previous; |
| Left->ParentBracket = Contexts.back().ContextKind; |
| |
| if (Contexts.back().CaretFound) |
| Left->setType(TT_ObjCBlockLBrace); |
| Contexts.back().CaretFound = false; |
| |
| ScopedContextCreator ContextCreator(*this, tok::l_brace, 1); |
| Contexts.back().ColonIsDictLiteral = true; |
| if (Left->is(BK_BracedInit)) |
| Contexts.back().IsExpression = true; |
| if (Style.Language == FormatStyle::LK_JavaScript && Left->Previous && |
| Left->Previous->is(TT_JsTypeColon)) |
| Contexts.back().IsExpression = false; |
| |
| unsigned CommaCount = 0; |
| while (CurrentToken) { |
| if (CurrentToken->is(tok::r_brace)) { |
| Left->MatchingParen = CurrentToken; |
| CurrentToken->MatchingParen = Left; |
| if (Style.AlignArrayOfStructures != FormatStyle::AIAS_None) { |
| if (Left->ParentBracket == tok::l_brace && |
| couldBeInStructArrayInitializer() && CommaCount > 0) { |
| Contexts.back().InStructArrayInitializer = true; |
| } |
| } |
| next(); |
| return true; |
| } |
| if (CurrentToken->isOneOf(tok::r_paren, tok::r_square)) |
| return false; |
| updateParameterCount(Left, CurrentToken); |
| if (CurrentToken->isOneOf(tok::colon, tok::l_brace, tok::less)) { |
| FormatToken *Previous = CurrentToken->getPreviousNonComment(); |
| if (Previous->is(TT_JsTypeOptionalQuestion)) |
| Previous = Previous->getPreviousNonComment(); |
| if ((CurrentToken->is(tok::colon) && |
| (!Contexts.back().ColonIsDictLiteral || !Style.isCpp())) || |
| Style.Language == FormatStyle::LK_Proto || |
| Style.Language == FormatStyle::LK_TextProto) { |
| Left->setType(TT_DictLiteral); |
| if (Previous->Tok.getIdentifierInfo() || |
| Previous->is(tok::string_literal)) |
| Previous->setType(TT_SelectorName); |
| } |
| if (CurrentToken->is(tok::colon) || |
| Style.Language == FormatStyle::LK_JavaScript) |
| Left->setType(TT_DictLiteral); |
| } |
| if (CurrentToken->is(tok::comma)) { |
| if (Style.Language == FormatStyle::LK_JavaScript) |
| Left->setType(TT_DictLiteral); |
| ++CommaCount; |
| } |
| if (!consumeToken()) |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| void updateParameterCount(FormatToken *Left, FormatToken *Current) { |
| // For ObjC methods, the number of parameters is calculated differently as |
| // method declarations have a different structure (the parameters are not |
| // inside a bracket scope). |
| if (Current->is(tok::l_brace) && Current->is(BK_Block)) |
| ++Left->BlockParameterCount; |
| if (Current->is(tok::comma)) { |
| ++Left->ParameterCount; |
| if (!Left->Role) |
| Left->Role.reset(new CommaSeparatedList(Style)); |
| Left->Role->CommaFound(Current); |
| } else if (Left->ParameterCount == 0 && Current->isNot(tok::comment)) { |
| Left->ParameterCount = 1; |
| } |
| } |
| |
| bool parseConditional() { |
| while (CurrentToken) { |
| if (CurrentToken->is(tok::colon)) { |
| CurrentToken->setType(TT_ConditionalExpr); |
| next(); |
| return true; |
| } |
| if (!consumeToken()) |
| return false; |
| } |
| return false; |
| } |
| |
| bool parseTemplateDeclaration() { |
| if (CurrentToken && CurrentToken->is(tok::less)) { |
| CurrentToken->setType(TT_TemplateOpener); |
| next(); |
| if (!parseAngle()) |
| return false; |
| if (CurrentToken) |
| CurrentToken->Previous->ClosesTemplateDeclaration = true; |
| return true; |
| } |
| return false; |
| } |
| |
| bool consumeToken() { |
| FormatToken *Tok = CurrentToken; |
| next(); |
| switch (Tok->Tok.getKind()) { |
| case tok::plus: |
| case tok::minus: |
| if (!Tok->Previous && Line.MustBeDeclaration) |
| Tok->setType(TT_ObjCMethodSpecifier); |
| break; |
| case tok::colon: |
| if (!Tok->Previous) |
| return false; |
| // Colons from ?: are handled in parseConditional(). |
| if (Style.Language == FormatStyle::LK_JavaScript) { |
| if (Contexts.back().ColonIsForRangeExpr || // colon in for loop |
| (Contexts.size() == 1 && // switch/case labels |
| !Line.First->isOneOf(tok::kw_enum, tok::kw_case)) || |
| Contexts.back().ContextKind == tok::l_paren || // function params |
| Contexts.back().ContextKind == tok::l_square || // array type |
| (!Contexts.back().IsExpression && |
| Contexts.back().ContextKind == tok::l_brace) || // object type |
| (Contexts.size() == 1 && |
| Line.MustBeDeclaration)) { // method/property declaration |
| Contexts.back().IsExpression = false; |
| Tok->setType(TT_JsTypeColon); |
| break; |
| } |
| } else if (Style.isCSharp()) { |
| if (Contexts.back().InCSharpAttributeSpecifier) { |
| Tok->setType(TT_AttributeColon); |
| break; |
| } |
| if (Contexts.back().ContextKind == tok::l_paren) { |
| Tok->setType(TT_CSharpNamedArgumentColon); |
| break; |
| } |
| } |
| if (Line.First->isOneOf(Keywords.kw_module, Keywords.kw_import) || |
| Line.First->startsSequence(tok::kw_export, Keywords.kw_module) || |
| Line.First->startsSequence(tok::kw_export, Keywords.kw_import)) { |
| Tok->setType(TT_ModulePartitionColon); |
| } else if (Contexts.back().ColonIsDictLiteral || |
| Style.Language == FormatStyle::LK_Proto || |
| Style.Language == FormatStyle::LK_TextProto) { |
| Tok->setType(TT_DictLiteral); |
| if (Style.Language == FormatStyle::LK_TextProto) { |
| if (FormatToken *Previous = Tok->getPreviousNonComment()) |
| Previous->setType(TT_SelectorName); |
| } |
| } else if (Contexts.back().ColonIsObjCMethodExpr || |
| Line.startsWith(TT_ObjCMethodSpecifier)) { |
| Tok->setType(TT_ObjCMethodExpr); |
| const FormatToken *BeforePrevious = Tok->Previous->Previous; |
| // Ensure we tag all identifiers in method declarations as |
| // TT_SelectorName. |
| bool UnknownIdentifierInMethodDeclaration = |
| Line.startsWith(TT_ObjCMethodSpecifier) && |
| Tok->Previous->is(tok::identifier) && Tok->Previous->is(TT_Unknown); |
| if (!BeforePrevious || |
| // FIXME(bug 36976): ObjC return types shouldn't use TT_CastRParen. |
| !(BeforePrevious->is(TT_CastRParen) || |
| (BeforePrevious->is(TT_ObjCMethodExpr) && |
| BeforePrevious->is(tok::colon))) || |
| BeforePrevious->is(tok::r_square) || |
| Contexts.back().LongestObjCSelectorName == 0 || |
| UnknownIdentifierInMethodDeclaration) { |
| Tok->Previous->setType(TT_SelectorName); |
| if (!Contexts.back().FirstObjCSelectorName) |
| Contexts.back().FirstObjCSelectorName = Tok->Previous; |
| else if (Tok->Previous->ColumnWidth > |
| Contexts.back().LongestObjCSelectorName) |
| Contexts.back().LongestObjCSelectorName = |
| Tok->Previous->ColumnWidth; |
| Tok->Previous->ParameterIndex = |
| Contexts.back().FirstObjCSelectorName->ObjCSelectorNameParts; |
| ++Contexts.back().FirstObjCSelectorName->ObjCSelectorNameParts; |
| } |
| } else if (Contexts.back().ColonIsForRangeExpr) { |
| Tok->setType(TT_RangeBasedForLoopColon); |
| } else if (CurrentToken && CurrentToken->is(tok::numeric_constant)) { |
| Tok->setType(TT_BitFieldColon); |
| } else if (Contexts.size() == 1 && |
| !Line.First->isOneOf(tok::kw_enum, tok::kw_case, |
| tok::kw_default)) { |
| FormatToken *Prev = Tok->getPreviousNonComment(); |
| if (!Prev) |
| break; |
| if (Prev->isOneOf(tok::r_paren, tok::kw_noexcept)) |
| Tok->setType(TT_CtorInitializerColon); |
| else if (Prev->is(tok::kw_try)) { |
| // Member initializer list within function try block. |
| FormatToken *PrevPrev = Prev->getPreviousNonComment(); |
| if (!PrevPrev) |
| break; |
| if (PrevPrev && PrevPrev->isOneOf(tok::r_paren, tok::kw_noexcept)) |
| Tok->setType(TT_CtorInitializerColon); |
| } else |
| Tok->setType(TT_InheritanceColon); |
| } else if (canBeObjCSelectorComponent(*Tok->Previous) && Tok->Next && |
| (Tok->Next->isOneOf(tok::r_paren, tok::comma) || |
| (canBeObjCSelectorComponent(*Tok->Next) && Tok->Next->Next && |
| Tok->Next->Next->is(tok::colon)))) { |
| // This handles a special macro in ObjC code where selectors including |
| // the colon are passed as macro arguments. |
| Tok->setType(TT_ObjCMethodExpr); |
| } else if (Contexts.back().ContextKind == tok::l_paren) { |
| Tok->setType(TT_InlineASMColon); |
| } |
| break; |
| case tok::pipe: |
| case tok::amp: |
| // | and & in declarations/type expressions represent union and |
| // intersection types, respectively. |
| if (Style.Language == FormatStyle::LK_JavaScript && |
| !Contexts.back().IsExpression) |
| Tok->setType(TT_JsTypeOperator); |
| break; |
| case tok::kw_if: |
| case tok::kw_while: |
| if (Tok->is(tok::kw_if) && CurrentToken && |
| CurrentToken->isOneOf(tok::kw_constexpr, tok::identifier)) |
| next(); |
| if (CurrentToken && CurrentToken->is(tok::l_paren)) { |
| next(); |
| if (!parseParens(/*LookForDecls=*/true)) |
| return false; |
| } |
| break; |
| case tok::kw_for: |
| if (Style.Language == FormatStyle::LK_JavaScript) { |
| // x.for and {for: ...} |
| if ((Tok->Previous && Tok->Previous->is(tok::period)) || |
| (Tok->Next && Tok->Next->is(tok::colon))) |
| break; |
| // JS' for await ( ... |
| if (CurrentToken && CurrentToken->is(Keywords.kw_await)) |
| next(); |
| } |
| Contexts.back().ColonIsForRangeExpr = true; |
| next(); |
| if (!parseParens()) |
| return false; |
| break; |
| case tok::l_paren: |
| // When faced with 'operator()()', the kw_operator handler incorrectly |
| // marks the first l_paren as a OverloadedOperatorLParen. Here, we make |
| // the first two parens OverloadedOperators and the second l_paren an |
| // OverloadedOperatorLParen. |
| if (Tok->Previous && Tok->Previous->is(tok::r_paren) && |
| Tok->Previous->MatchingParen && |
| Tok->Previous->MatchingParen->is(TT_OverloadedOperatorLParen)) { |
| Tok->Previous->setType(TT_OverloadedOperator); |
| Tok->Previous->MatchingParen->setType(TT_OverloadedOperator); |
| Tok->setType(TT_OverloadedOperatorLParen); |
| } |
| |
| if (!parseParens()) |
| return false; |
| if (Line.MustBeDeclaration && Contexts.size() == 1 && |
| !Contexts.back().IsExpression && !Line.startsWith(TT_ObjCProperty) && |
| !Tok->is(TT_TypeDeclarationParen) && |
| (!Tok->Previous || !Tok->Previous->isOneOf(tok::kw___attribute, |
| TT_LeadingJavaAnnotation))) |
| Line.MightBeFunctionDecl = true; |
| break; |
| case tok::l_square: |
| if (!parseSquare()) |
| return false; |
| break; |
| case tok::l_brace: |
| if (Style.Language == FormatStyle::LK_TextProto) { |
| FormatToken *Previous = Tok->getPreviousNonComment(); |
| if (Previous && Previous->getType() != TT_DictLiteral) |
| Previous->setType(TT_SelectorName); |
| } |
| if (!parseBrace()) |
| return false; |
| break; |
| case tok::less: |
| if (parseAngle()) { |
| Tok->setType(TT_TemplateOpener); |
| // In TT_Proto, we must distignuish between: |
| // map<key, value> |
| // msg < item: data > |
| // msg: < item: data > |
| // In TT_TextProto, map<key, value> does not occur. |
| if (Style.Language == FormatStyle::LK_TextProto || |
| (Style.Language == FormatStyle::LK_Proto && Tok->Previous && |
| Tok->Previous->isOneOf(TT_SelectorName, TT_DictLiteral))) { |
| Tok->setType(TT_DictLiteral); |
| FormatToken *Previous = Tok->getPreviousNonComment(); |
| if (Previous && Previous->getType() != TT_DictLiteral) |
| Previous->setType(TT_SelectorName); |
| } |
| } else { |
| Tok->setType(TT_BinaryOperator); |
| NonTemplateLess.insert(Tok); |
| CurrentToken = Tok; |
| next(); |
| } |
| break; |
| case tok::r_paren: |
| case tok::r_square: |
| return false; |
| case tok::r_brace: |
| // Lines can start with '}'. |
| if (Tok->Previous) |
| return false; |
| break; |
| case tok::greater: |
| if (Style.Language != FormatStyle::LK_TextProto) |
| Tok->setType(TT_BinaryOperator); |
| if (Tok->Previous && Tok->Previous->is(TT_TemplateCloser)) |
| Tok->SpacesRequiredBefore = 1; |
| break; |
| case tok::kw_operator: |
| if (Style.Language == FormatStyle::LK_TextProto || |
| Style.Language == FormatStyle::LK_Proto) |
| break; |
| while (CurrentToken && |
| !CurrentToken->isOneOf(tok::l_paren, tok::semi, tok::r_paren)) { |
| if (CurrentToken->isOneOf(tok::star, tok::amp)) |
| CurrentToken->setType(TT_PointerOrReference); |
| consumeToken(); |
| if (CurrentToken && CurrentToken->is(tok::comma) && |
| CurrentToken->Previous->isNot(tok::kw_operator)) |
| break; |
| if (CurrentToken && CurrentToken->Previous->isOneOf( |
| TT_BinaryOperator, TT_UnaryOperator, tok::comma, |
| tok::star, tok::arrow, tok::amp, tok::ampamp)) |
| CurrentToken->Previous->setType(TT_OverloadedOperator); |
| } |
| if (CurrentToken && CurrentToken->is(tok::l_paren)) |
| CurrentToken->setType(TT_OverloadedOperatorLParen); |
| if (CurrentToken && CurrentToken->Previous->is(TT_BinaryOperator)) |
| CurrentToken->Previous->setType(TT_OverloadedOperator); |
| break; |
| case tok::question: |
| if (Style.Language == FormatStyle::LK_JavaScript && Tok->Next && |
| Tok->Next->isOneOf(tok::semi, tok::comma, tok::colon, tok::r_paren, |
| tok::r_brace)) { |
| // Question marks before semicolons, colons, etc. indicate optional |
| // types (fields, parameters), e.g. |
| // function(x?: string, y?) {...} |
| // class X { y?; } |
| Tok->setType(TT_JsTypeOptionalQuestion); |
| break; |
| } |
| // Declarations cannot be conditional expressions, this can only be part |
| // of a type declaration. |
| if (Line.MustBeDeclaration && !Contexts.back().IsExpression && |
| Style.Language == FormatStyle::LK_JavaScript) |
| break; |
| if (Style.isCSharp()) { |
| // `Type?)`, `Type?>`, `Type? name;` and `Type? name =` can only be |
| // nullable types. |
| // Line.MustBeDeclaration will be true for `Type? name;`. |
| if ((!Contexts.back().IsExpression && Line.MustBeDeclaration) || |
| (Tok->Next && Tok->Next->isOneOf(tok::r_paren, tok::greater)) || |
| (Tok->Next && Tok->Next->is(tok::identifier) && Tok->Next->Next && |
| Tok->Next->Next->is(tok::equal))) { |
| Tok->setType(TT_CSharpNullable); |
| break; |
| } |
| } |
| parseConditional(); |
| break; |
| case tok::kw_template: |
| parseTemplateDeclaration(); |
| break; |
| case tok::comma: |
| if (Contexts.back().InCtorInitializer) |
| Tok->setType(TT_CtorInitializerComma); |
| else if (Contexts.back().InInheritanceList) |
| Tok->setType(TT_InheritanceComma); |
| else if (Contexts.back().FirstStartOfName && |
| (Contexts.size() == 1 || Line.startsWith(tok::kw_for))) { |
| Contexts.back().FirstStartOfName->PartOfMultiVariableDeclStmt = true; |
| Line.IsMultiVariableDeclStmt = true; |
| } |
| if (Contexts.back().IsForEachMacro) |
| Contexts.back().IsExpression = true; |
| break; |
| case tok::identifier: |
| if (Tok->isOneOf(Keywords.kw___has_include, |
| Keywords.kw___has_include_next)) { |
| parseHasInclude(); |
| } |
| if (Style.isCSharp() && Tok->is(Keywords.kw_where) && Tok->Next && |
| Tok->Next->isNot(tok::l_paren)) { |
| Tok->setType(TT_CSharpGenericTypeConstraint); |
| parseCSharpGenericTypeConstraint(); |
| } |
| break; |
| default: |
| break; |
| } |
| return true; |
| } |
| |
| void parseCSharpGenericTypeConstraint() { |
| int OpenAngleBracketsCount = 0; |
| while (CurrentToken) { |
| if (CurrentToken->is(tok::less)) { |
| // parseAngle is too greedy and will consume the whole line. |
| CurrentToken->setType(TT_TemplateOpener); |
| ++OpenAngleBracketsCount; |
| next(); |
| } else if (CurrentToken->is(tok::greater)) { |
| CurrentToken->setType(TT_TemplateCloser); |
| --OpenAngleBracketsCount; |
| next(); |
| } else if (CurrentToken->is(tok::comma) && OpenAngleBracketsCount == 0) { |
| // We allow line breaks after GenericTypeConstraintComma's |
| // so do not flag commas in Generics as GenericTypeConstraintComma's. |
| CurrentToken->setType(TT_CSharpGenericTypeConstraintComma); |
| next(); |
| } else if (CurrentToken->is(Keywords.kw_where)) { |
| CurrentToken->setType(TT_CSharpGenericTypeConstraint); |
| next(); |
| } else if (CurrentToken->is(tok::colon)) { |
| CurrentToken->setType(TT_CSharpGenericTypeConstraintColon); |
| next(); |
| } else { |
| next(); |
| } |
| } |
| } |
| |
| void parseIncludeDirective() { |
| if (CurrentToken && CurrentToken->is(tok::less)) { |
| next(); |
| while (CurrentToken) { |
| // Mark tokens up to the trailing line comments as implicit string |
| // literals. |
| if (CurrentToken->isNot(tok::comment) && |
| !CurrentToken->TokenText.startswith("//")) |
| CurrentToken->setType(TT_ImplicitStringLiteral); |
| next(); |
| } |
| } |
| } |
| |
| void parseWarningOrError() { |
| next(); |
| // We still want to format the whitespace left of the first token of the |
| // warning or error. |
| next(); |
| while (CurrentToken) { |
| CurrentToken->setType(TT_ImplicitStringLiteral); |
| next(); |
| } |
| } |
| |
| void parsePragma() { |
| next(); // Consume "pragma". |
| if (CurrentToken && |
| CurrentToken->isOneOf(Keywords.kw_mark, Keywords.kw_option)) { |
| bool IsMark = CurrentToken->is(Keywords.kw_mark); |
| next(); // Consume "mark". |
| next(); // Consume first token (so we fix leading whitespace). |
| while (CurrentToken) { |
| if (IsMark || CurrentToken->Previous->is(TT_BinaryOperator)) |
| CurrentToken->setType(TT_ImplicitStringLiteral); |
| next(); |
| } |
| } |
| } |
| |
| void parseHasInclude() { |
| if (!CurrentToken || !CurrentToken->is(tok::l_paren)) |
| return; |
| next(); // '(' |
| parseIncludeDirective(); |
| next(); // ')' |
| } |
| |
| LineType parsePreprocessorDirective() { |
| bool IsFirstToken = CurrentToken->IsFirst; |
| LineType Type = LT_PreprocessorDirective; |
| next(); |
| if (!CurrentToken) |
| return Type; |
| |
| if (Style.Language == FormatStyle::LK_JavaScript && IsFirstToken) { |
| // JavaScript files can contain shebang lines of the form: |
| // #!/usr/bin/env node |
| // Treat these like C++ #include directives. |
| while (CurrentToken) { |
| // Tokens cannot be comments here. |
| CurrentToken->setType(TT_ImplicitStringLiteral); |
| next(); |
| } |
| return LT_ImportStatement; |
| } |
| |
| if (CurrentToken->Tok.is(tok::numeric_constant)) { |
| CurrentToken->SpacesRequiredBefore = 1; |
| return Type; |
| } |
| // Hashes in the middle of a line can lead to any strange token |
| // sequence. |
| if (!CurrentToken->Tok.getIdentifierInfo()) |
| return Type; |
| switch (CurrentToken->Tok.getIdentifierInfo()->getPPKeywordID()) { |
| case tok::pp_include: |
| case tok::pp_include_next: |
| case tok::pp_import: |
| next(); |
| parseIncludeDirective(); |
| Type = LT_ImportStatement; |
| break; |
| case tok::pp_error: |
| case tok::pp_warning: |
| parseWarningOrError(); |
| break; |
| case tok::pp_pragma: |
| parsePragma(); |
| break; |
| case tok::pp_if: |
| case tok::pp_elif: |
| Contexts.back().IsExpression = true; |
| next(); |
| parseLine(); |
| break; |
| default: |
| break; |
| } |
| while (CurrentToken) { |
| FormatToken *Tok = CurrentToken; |
| next(); |
| if (Tok->is(tok::l_paren)) |
| parseParens(); |
| else if (Tok->isOneOf(Keywords.kw___has_include, |
| Keywords.kw___has_include_next)) |
| parseHasInclude(); |
| } |
| return Type; |
| } |
| |
| public: |
| LineType parseLine() { |
| if (!CurrentToken) |
| return LT_Invalid; |
| NonTemplateLess.clear(); |
| if (CurrentToken->is(tok::hash)) |
| return parsePreprocessorDirective(); |
| |
| // Directly allow to 'import <string-literal>' to support protocol buffer |
| // definitions (github.com/google/protobuf) or missing "#" (either way we |
| // should not break the line). |
| IdentifierInfo *Info = CurrentToken->Tok.getIdentifierInfo(); |
| if ((Style.Language == FormatStyle::LK_Java && |
| CurrentToken->is(Keywords.kw_package)) || |
| (Info && Info->getPPKeywordID() == tok::pp_import && |
| CurrentToken->Next && |
| CurrentToken->Next->isOneOf(tok::string_literal, tok::identifier, |
| tok::kw_static))) { |
| next(); |
| parseIncludeDirective(); |
| return LT_ImportStatement; |
| } |
| |
| // If this line starts and ends in '<' and '>', respectively, it is likely |
| // part of "#define <a/b.h>". |
| if (CurrentToken->is(tok::less) && Line.Last->is(tok::greater)) { |
| parseIncludeDirective(); |
| return LT_ImportStatement; |
| } |
| |
| // In .proto files, top-level options and package statements are very |
| // similar to import statements and should not be line-wrapped. |
| if (Style.Language == FormatStyle::LK_Proto && Line.Level == 0 && |
| CurrentToken->isOneOf(Keywords.kw_option, Keywords.kw_package)) { |
| next(); |
| if (CurrentToken && CurrentToken->is(tok::identifier)) { |
| while (CurrentToken) |
| next(); |
| return LT_ImportStatement; |
| } |
| } |
| |
| bool KeywordVirtualFound = false; |
| bool ImportStatement = false; |
| |
| // import {...} from '...'; |
| if (Style.Language == FormatStyle::LK_JavaScript && |
| CurrentToken->is(Keywords.kw_import)) |
| ImportStatement = true; |
| |
| while (CurrentToken) { |
| if (CurrentToken->is(tok::kw_virtual)) |
| KeywordVirtualFound = true; |
| if (Style.Language == FormatStyle::LK_JavaScript) { |
| // export {...} from '...'; |
| // An export followed by "from 'some string';" is a re-export from |
| // another module identified by a URI and is treated as a |
| // LT_ImportStatement (i.e. prevent wraps on it for long URIs). |
| // Just "export {...};" or "export class ..." should not be treated as |
| // an import in this sense. |
| if (Line.First->is(tok::kw_export) && |
| CurrentToken->is(Keywords.kw_from) && CurrentToken->Next && |
| CurrentToken->Next->isStringLiteral()) |
| ImportStatement = true; |
| if (isClosureImportStatement(*CurrentToken)) |
| ImportStatement = true; |
| } |
| if (!consumeToken()) |
| return LT_Invalid; |
| } |
| if (KeywordVirtualFound) |
| return LT_VirtualFunctionDecl; |
| if (ImportStatement) |
| return LT_ImportStatement; |
| |
| if (Line.startsWith(TT_ObjCMethodSpecifier)) { |
| if (Contexts.back().FirstObjCSelectorName) |
| Contexts.back().FirstObjCSelectorName->LongestObjCSelectorName = |
| Contexts.back().LongestObjCSelectorName; |
| return LT_ObjCMethodDecl; |
| } |
| |
| for (const auto &ctx : Contexts) { |
| if (ctx.InStructArrayInitializer) { |
| return LT_ArrayOfStructInitializer; |
| } |
| } |
| |
| return LT_Other; |
| } |
| |
| private: |
| bool isClosureImportStatement(const FormatToken &Tok) { |
| // FIXME: Closure-library specific stuff should not be hard-coded but be |
| // configurable. |
| return Tok.TokenText == "goog" && Tok.Next && Tok.Next->is(tok::period) && |
| Tok.Next->Next && |
| (Tok.Next->Next->TokenText == "module" || |
| Tok.Next->Next->TokenText == "provide" || |
| Tok.Next->Next->TokenText == "require" || |
| Tok.Next->Next->TokenText == "requireType" || |
| Tok.Next->Next->TokenText == "forwardDeclare") && |
| Tok.Next->Next->Next && Tok.Next->Next->Next->is(tok::l_paren); |
| } |
| |
| void resetTokenMetadata(FormatToken *Token) { |
| if (!Token) |
| return; |
| |
| // Reset token type in case we have already looked at it and then |
| // recovered from an error (e.g. failure to find the matching >). |
| if (!CurrentToken->isOneOf( |
| TT_LambdaLSquare, TT_LambdaLBrace, TT_AttributeMacro, TT_IfMacro, |
| TT_ForEachMacro, TT_TypenameMacro, TT_FunctionLBrace, |
| TT_ImplicitStringLiteral, TT_InlineASMBrace, TT_FatArrow, |
| TT_LambdaArrow, TT_NamespaceMacro, TT_OverloadedOperator, |
| TT_RegexLiteral, TT_TemplateString, TT_ObjCStringLiteral, |
| TT_UntouchableMacroFunc, TT_ConstraintJunctions, |
| TT_StatementAttributeLikeMacro)) |
| CurrentToken->setType(TT_Unknown); |
| CurrentToken->Role.reset(); |
| CurrentToken->MatchingParen = nullptr; |
| CurrentToken->FakeLParens.clear(); |
| CurrentToken->FakeRParens = 0; |
| } |
| |
| void next() { |
| if (CurrentToken) { |
| CurrentToken->NestingLevel = Contexts.size() - 1; |
| CurrentToken->BindingStrength = Contexts.back().BindingStrength; |
| modifyContext(*CurrentToken); |
| determineTokenType(*CurrentToken); |
| CurrentToken = CurrentToken->Next; |
| } |
| |
| resetTokenMetadata(CurrentToken); |
| } |
| |
| /// A struct to hold information valid in a specific context, e.g. |
| /// a pair of parenthesis. |
| struct Context { |
| Context(tok::TokenKind ContextKind, unsigned BindingStrength, |
| bool IsExpression) |
| : ContextKind(ContextKind), BindingStrength(BindingStrength), |
| IsExpression(IsExpression) {} |
| |
| tok::TokenKind ContextKind; |
| unsigned BindingStrength; |
| bool IsExpression; |
| unsigned LongestObjCSelectorName = 0; |
| bool ColonIsForRangeExpr = false; |
| bool ColonIsDictLiteral = false; |
| bool ColonIsObjCMethodExpr = false; |
| FormatToken *FirstObjCSelectorName = nullptr; |
| FormatToken *FirstStartOfName = nullptr; |
| bool CanBeExpression = true; |
| bool InTemplateArgument = false; |
| bool InCtorInitializer = false; |
| bool InInheritanceList = false; |
| bool CaretFound = false; |
| bool IsForEachMacro = false; |
| bool InCpp11AttributeSpecifier = false; |
| bool InCSharpAttributeSpecifier = false; |
| bool InStructArrayInitializer = false; |
| }; |
| |
| /// Puts a new \c Context onto the stack \c Contexts for the lifetime |
| /// of each instance. |
| struct ScopedContextCreator { |
| AnnotatingParser &P; |
| |
| ScopedContextCreator(AnnotatingParser &P, tok::TokenKind ContextKind, |
| unsigned Increase) |
| : P(P) { |
| P.Contexts.push_back(Context(ContextKind, |
| P.Contexts.back().BindingStrength + Increase, |
| P.Contexts.back().IsExpression)); |
| } |
| |
| ~ScopedContextCreator() { |
| if (P.Style.AlignArrayOfStructures != FormatStyle::AIAS_None) { |
| if (P.Contexts.back().InStructArrayInitializer) { |
| P.Contexts.pop_back(); |
| P.Contexts.back().InStructArrayInitializer = true; |
| return; |
| } |
| } |
| P.Contexts.pop_back(); |
| } |
| }; |
| |
| void modifyContext(const FormatToken &Current) { |
| if (Current.getPrecedence() == prec::Assignment && |
| !Line.First->isOneOf(tok::kw_template, tok::kw_using, tok::kw_return) && |
| // Type aliases use `type X = ...;` in TypeScript and can be exported |
| // using `export type ...`. |
| !(Style.Language == FormatStyle::LK_JavaScript && |
| (Line.startsWith(Keywords.kw_type, tok::identifier) || |
| Line.startsWith(tok::kw_export, Keywords.kw_type, |
| tok::identifier))) && |
| (!Current.Previous || Current.Previous->isNot(tok::kw_operator))) { |
| Contexts.back().IsExpression = true; |
| if (!Line.startsWith(TT_UnaryOperator)) { |
| for (FormatToken *Previous = Current.Previous; |
| Previous && Previous->Previous && |
| !Previous->Previous->isOneOf(tok::comma, tok::semi); |
| Previous = Previous->Previous) { |
| if (Previous->isOneOf(tok::r_square, tok::r_paren)) { |
| Previous = Previous->MatchingParen; |
| if (!Previous) |
| break; |
| } |
| if (Previous->opensScope()) |
| break; |
| if (Previous->isOneOf(TT_BinaryOperator, TT_UnaryOperator) && |
| Previous->isOneOf(tok::star, tok::amp, tok::ampamp) && |
| Previous->Previous && Previous->Previous->isNot(tok::equal)) |
| Previous->setType(TT_PointerOrReference); |
| } |
| } |
| } else if (Current.is(tok::lessless) && |
| (!Current.Previous || !Current.Previous->is(tok::kw_operator))) { |
| Contexts.back().IsExpression = true; |
| } else if (Current.isOneOf(tok::kw_return, tok::kw_throw)) { |
| Contexts.back().IsExpression = true; |
| } else if (Current.is(TT_TrailingReturnArrow)) { |
| Contexts.back().IsExpression = false; |
| } else if (Current.is(TT_LambdaArrow) || Current.is(Keywords.kw_assert)) { |
| Contexts.back().IsExpression = Style.Language == FormatStyle::LK_Java; |
| } else if (Current.Previous && |
| Current.Previous->is(TT_CtorInitializerColon)) { |
| Contexts.back().IsExpression = true; |
| Contexts.back().InCtorInitializer = true; |
| } else if (Current.Previous && Current.Previous->is(TT_InheritanceColon)) { |
| Contexts.back().InInheritanceList = true; |
| } else if (Current.isOneOf(tok::r_paren, tok::greater, tok::comma)) { |
| for (FormatToken *Previous = Current.Previous; |
| Previous && Previous->isOneOf(tok::star, tok::amp); |
| Previous = Previous->Previous) |
| Previous->setType(TT_PointerOrReference); |
| if (Line.MustBeDeclaration && !Contexts.front().InCtorInitializer) |
| Contexts.back().IsExpression = false; |
| } else if (Current.is(tok::kw_new)) { |
| Contexts.back().CanBeExpression = false; |
| } else if (Current.is(tok::semi) || |
| (Current.is(tok::exclaim) && Current.Previous && |
| !Current.Previous->is(tok::kw_operator))) { |
| // This should be the condition or increment in a for-loop. |
| // But not operator !() (can't use TT_OverloadedOperator here as its not |
| // been annotated yet). |
| Contexts.back().IsExpression = true; |
| } |
| } |
| |
| static FormatToken *untilMatchingParen(FormatToken *Current) { |
| // Used when `MatchingParen` is not yet established. |
| int ParenLevel = 0; |
| while (Current) { |
| if (Current->is(tok::l_paren)) |
| ParenLevel++; |
| if (Current->is(tok::r_paren)) |
| ParenLevel--; |
| if (ParenLevel < 1) |
| break; |
| Current = Current->Next; |
| } |
| return Current; |
| } |
| |
| static bool isDeductionGuide(FormatToken &Current) { |
| // Look for a deduction guide template<T> A(...) -> A<...>; |
| if (Current.Previous && Current.Previous->is(tok::r_paren) && |
| Current.startsSequence(tok::arrow, tok::identifier, tok::less)) { |
| // Find the TemplateCloser. |
| FormatToken *TemplateCloser = Current.Next->Next; |
| int NestingLevel = 0; |
| while (TemplateCloser) { |
| // Skip over an expressions in parens A<(3 < 2)>; |
| if (TemplateCloser->is(tok::l_paren)) { |
| // No Matching Paren yet so skip to matching paren |
| TemplateCloser = untilMatchingParen(TemplateCloser); |
| if (!TemplateCloser) |
| break; |
| } |
| if (TemplateCloser->is(tok::less)) |
| NestingLevel++; |
| if (TemplateCloser->is(tok::greater)) |
| NestingLevel--; |
| if (NestingLevel < 1) |
| break; |
| TemplateCloser = TemplateCloser->Next; |
| } |
| // Assuming we have found the end of the template ensure its followed |
| // with a semi-colon. |
| if (TemplateCloser && TemplateCloser->Next && |
| TemplateCloser->Next->is(tok::semi) && |
| Current.Previous->MatchingParen) { |
| // Determine if the identifier `A` prior to the A<..>; is the same as |
| // prior to the A(..) |
| FormatToken *LeadingIdentifier = |
| Current.Previous->MatchingParen->Previous; |
| |
| // Differentiate a deduction guide by seeing the |
| // > of the template prior to the leading identifier. |
| if (LeadingIdentifier) { |
| FormatToken *PriorLeadingIdentifier = LeadingIdentifier->Previous; |
| // Skip back past explicit decoration |
| if (PriorLeadingIdentifier && |
| PriorLeadingIdentifier->is(tok::kw_explicit)) |
| PriorLeadingIdentifier = PriorLeadingIdentifier->Previous; |
| |
| return (PriorLeadingIdentifier && |
| PriorLeadingIdentifier->is(TT_TemplateCloser) && |
| LeadingIdentifier->TokenText == Current.Next->TokenText); |
| } |
| } |
| } |
| return false; |
| } |
| |
| void determineTokenType(FormatToken &Current) { |
| if (!Current.is(TT_Unknown)) |
| // The token type is already known. |
| return; |
| |
| if ((Style.Language == FormatStyle::LK_JavaScript || Style.isCSharp()) && |
| Current.is(tok::exclaim)) { |
| if (Current.Previous) { |
| bool IsIdentifier = |
| Style.Language == FormatStyle::LK_JavaScript |
| ? Keywords.IsJavaScriptIdentifier( |
| *Current.Previous, /* AcceptIdentifierName= */ true) |
| : Current.Previous->is(tok::identifier); |
| if (IsIdentifier || |
| Current.Previous->isOneOf( |
| tok::kw_namespace, tok::r_paren, tok::r_square, tok::r_brace, |
| tok::kw_false, tok::kw_true, Keywords.kw_type, Keywords.kw_get, |
| Keywords.kw_set) || |
| Current.Previous->Tok.isLiteral()) { |
| Current.setType(TT_NonNullAssertion); |
| return; |
| } |
| } |
| if (Current.Next && |
| Current.Next->isOneOf(TT_BinaryOperator, Keywords.kw_as)) { |
| Current.setType(TT_NonNullAssertion); |
| return; |
| } |
| } |
| |
| // Line.MightBeFunctionDecl can only be true after the parentheses of a |
| // function declaration have been found. In this case, 'Current' is a |
| // trailing token of this declaration and thus cannot be a name. |
| if (Current.is(Keywords.kw_instanceof)) { |
| Current.setType(TT_BinaryOperator); |
| } else if (isStartOfName(Current) && |
| (!Line.MightBeFunctionDecl || Current.NestingLevel != 0)) { |
| Contexts.back().FirstStartOfName = &Current; |
| Current.setType(TT_StartOfName); |
| } else if (Current.is(tok::semi)) { |
| // Reset FirstStartOfName after finding a semicolon so that a for loop |
| // with multiple increment statements is not confused with a for loop |
| // having multiple variable declarations. |
| Contexts.back().FirstStartOfName = nullptr; |
| } else if (Current.isOneOf(tok::kw_auto, tok::kw___auto_type)) { |
| AutoFound = true; |
| } else if (Current.is(tok::arrow) && |
| Style.Language == FormatStyle::LK_Java) { |
| Current.setType(TT_LambdaArrow); |
| } else if (Current.is(tok::arrow) && AutoFound && Line.MustBeDeclaration && |
| Current.NestingLevel == 0 && |
| !Current.Previous->is(tok::kw_operator)) { |
| // not auto operator->() -> xxx; |
| Current.setType(TT_TrailingReturnArrow); |
| } else if (Current.is(tok::arrow) && Current.Previous && |
| Current.Previous->is(tok::r_brace)) { |
| // Concept implicit conversion constraint needs to be treated like |
| // a trailing return type ... } -> <type>. |
| Current.setType(TT_TrailingReturnArrow); |
| } else if (isDeductionGuide(Current)) { |
| // Deduction guides trailing arrow " A(...) -> A<T>;". |
| Current.setType(TT_TrailingReturnArrow); |
| } else if (Current.isOneOf(tok::star, tok::amp, tok::ampamp)) { |
| Current.setType(determineStarAmpUsage( |
| Current, |
| Contexts.back().CanBeExpression && Contexts.back().IsExpression, |
| Contexts.back().InTemplateArgument)); |
| } else if (Current.isOneOf(tok::minus, tok::plus, tok::caret)) { |
| Current.setType(determinePlusMinusCaretUsage(Current)); |
| if (Current.is(TT_UnaryOperator) && Current.is(tok::caret)) |
| Contexts.back().CaretFound = true; |
| } else if (Current.isOneOf(tok::minusminus, tok::plusplus)) { |
| Current.setType(determineIncrementUsage(Current)); |
| } else if (Current.isOneOf(tok::exclaim, tok::tilde)) { |
| Current.setType(TT_UnaryOperator); |
| } else if (Current.is(tok::question)) { |
| if (Style.Language == FormatStyle::LK_JavaScript && |
| Line.MustBeDeclaration && !Contexts.back().IsExpression) { |
| // In JavaScript, `interface X { foo?(): bar; }` is an optional method |
| // on the interface, not a ternary expression. |
| Current.setType(TT_JsTypeOptionalQuestion); |
| } else { |
| Current.setType(TT_ConditionalExpr); |
| } |
| } else if (Current.isBinaryOperator() && |
| (!Current.Previous || Current.Previous->isNot(tok::l_square)) && |
| (!Current.is(tok::greater) && |
| Style.Language != FormatStyle::LK_TextProto)) { |
| Current.setType(TT_BinaryOperator); |
| } else if (Current.is(tok::comment)) { |
| if (Current.TokenText.startswith("/*")) { |
| if (Current.TokenText.endswith("*/")) |
| Current.setType(TT_BlockComment); |
| else |
| // The lexer has for some reason determined a comment here. But we |
| // cannot really handle it, if it isn't properly terminated. |
| Current.Tok.setKind(tok::unknown); |
| } else { |
| Current.setType(TT_LineComment); |
| } |
| } else if (Current.is(tok::r_paren)) { |
| if (rParenEndsCast(Current)) |
| Current.setType(TT_CastRParen); |
| if (Current.MatchingParen && Current.Next && |
| !Current.Next->isBinaryOperator() && |
| !Current.Next->isOneOf(tok::semi, tok::colon, tok::l_brace, |
| tok::comma, tok::period, tok::arrow, |
| tok::coloncolon)) |
| if (FormatToken *AfterParen = Current.MatchingParen->Next) { |
| // Make sure this isn't the return type of an Obj-C block declaration |
| if (AfterParen->Tok.isNot(tok::caret)) { |
| if (FormatToken *BeforeParen = Current.MatchingParen->Previous) |
| if (BeforeParen->is(tok::identifier) && |
| !BeforeParen->is(TT_TypenameMacro) && |
| BeforeParen->TokenText == BeforeParen->TokenText.upper() && |
| (!BeforeParen->Previous || |
| BeforeParen->Previous->ClosesTemplateDeclaration)) |
| Current.setType(TT_FunctionAnnotationRParen); |
| } |
| } |
| } else if (Current.is(tok::at) && Current.Next && |
| Style.Language != FormatStyle::LK_JavaScript && |
| Style.Language != FormatStyle::LK_Java) { |
| // In Java & JavaScript, "@..." is a decorator or annotation. In ObjC, it |
| // marks declarations and properties that need special formatting. |
| switch (Current.Next->Tok.getObjCKeywordID()) { |
| case tok::objc_interface: |
| case tok::objc_implementation: |
| case tok::objc_protocol: |
| Current.setType(TT_ObjCDecl); |
| break; |
| case tok::objc_property: |
| Current.setType(TT_ObjCProperty); |
| break; |
| default: |
| break; |
| } |
| } else if (Current.is(tok::period)) { |
| FormatToken *PreviousNoComment = Current.getPreviousNonComment(); |
| if (PreviousNoComment && |
| PreviousNoComment->isOneOf(tok::comma, tok::l_brace)) |
| Current.setType(TT_DesignatedInitializerPeriod); |
| else if (Style.Language == FormatStyle::LK_Java && Current.Previous && |
| Current.Previous->isOneOf(TT_JavaAnnotation, |
| TT_LeadingJavaAnnotation)) { |
| Current.setType(Current.Previous->getType()); |
| } |
| } else if (canBeObjCSelectorComponent(Current) && |
| // FIXME(bug 36976): ObjC return types shouldn't use |
| // TT_CastRParen. |
| Current.Previous && Current.Previous->is(TT_CastRParen) && |
| Current.Previous->MatchingParen && |
| Current.Previous->MatchingParen->Previous && |
| Current.Previous->MatchingParen->Previous->is( |
| TT_ObjCMethodSpecifier)) { |
| // This is the first part of an Objective-C selector name. (If there's no |
| // colon after this, this is the only place which annotates the identifier |
| // as a selector.) |
| Current.setType(TT_SelectorName); |
| } else if (Current.isOneOf(tok::identifier, tok::kw_const, tok::kw_noexcept, |
| tok::kw_requires) && |
| Current.Previous && |
| !Current.Previous->isOneOf(tok::equal, tok::at) && |
| Line.MightBeFunctionDecl && Contexts.size() == 1) { |
| // Line.MightBeFunctionDecl can only be true after the parentheses of a |
| // function declaration have been found. |
| Current.setType(TT_TrailingAnnotation); |
| } else if ((Style.Language == FormatStyle::LK_Java || |
| Style.Language == FormatStyle::LK_JavaScript) && |
| Current.Previous) { |
| if (Current.Previous->is(tok::at) && |
| Current.isNot(Keywords.kw_interface)) { |
| const FormatToken &AtToken = *Current.Previous; |
| const FormatToken *Previous = AtToken.getPreviousNonComment(); |
| if (!Previous || Previous->is(TT_LeadingJavaAnnotation)) |
| Current.setType(TT_LeadingJavaAnnotation); |
| else |
| Current.setType(TT_JavaAnnotation); |
| } else if (Current.Previous->is(tok::period) && |
| Current.Previous->isOneOf(TT_JavaAnnotation, |
| TT_LeadingJavaAnnotation)) { |
| Current.setType(Current.Previous->getType()); |
| } |
| } |
| } |
| |
| /// Take a guess at whether \p Tok starts a name of a function or |
| /// variable declaration. |
| /// |
| /// This is a heuristic based on whether \p Tok is an identifier following |
| /// something that is likely a type. |
| bool isStartOfName(const FormatToken &Tok) { |
| if (Tok.isNot(tok::identifier) || !Tok.Previous) |
| return false; |
| |
| if (Tok.Previous->isOneOf(TT_LeadingJavaAnnotation, Keywords.kw_instanceof, |
| Keywords.kw_as)) |
| return false; |
| if (Style.Language == FormatStyle::LK_JavaScript && |
| Tok.Previous->is(Keywords.kw_in)) |
| return false; |
| |
| // Skip "const" as it does not have an influence on whether this is a name. |
| FormatToken *PreviousNotConst = Tok.getPreviousNonComment(); |
| while (PreviousNotConst && PreviousNotConst->is(tok::kw_const)) |
| PreviousNotConst = PreviousNotConst->getPreviousNonComment(); |
| |
| if (!PreviousNotConst) |
| return false; |
| |
| bool IsPPKeyword = PreviousNotConst->is(tok::identifier) && |
| PreviousNotConst->Previous && |
| PreviousNotConst->Previous->is(tok::hash); |
| |
| if (PreviousNotConst->is(TT_TemplateCloser)) |
| return PreviousNotConst && PreviousNotConst->MatchingParen && |
| PreviousNotConst->MatchingParen->Previous && |
| PreviousNotConst->MatchingParen->Previous->isNot(tok::period) && |
| PreviousNotConst->MatchingParen->Previous->isNot(tok::kw_template); |
| |
| if (PreviousNotConst->is(tok::r_paren) && |
| PreviousNotConst->is(TT_TypeDeclarationParen)) |
| return true; |
| |
| return (!IsPPKeyword && |
| PreviousNotConst->isOneOf(tok::identifier, tok::kw_auto)) || |
| PreviousNotConst->is(TT_PointerOrReference) || |
| PreviousNotConst->isSimpleTypeSpecifier(); |
| } |
| |
| /// Determine whether ')' is ending a cast. |
| bool rParenEndsCast(const FormatToken &Tok) { |
| // C-style casts are only used in C++, C# and Java. |
| if (!Style.isCSharp() && !Style.isCpp() && |
| Style.Language != FormatStyle::LK_Java) |
| return false; |
| |
| // Empty parens aren't casts and there are no casts at the end of the line. |
| if (Tok.Previous == Tok.MatchingParen || !Tok.Next || !Tok.MatchingParen) |
| return false; |
| |
| FormatToken *LeftOfParens = Tok.MatchingParen->getPreviousNonComment(); |
| if (LeftOfParens) { |
| // If there is a closing parenthesis left of the current parentheses, |
| // look past it as these might be chained casts. |
| if (LeftOfParens->is(tok::r_paren)) { |
| if (!LeftOfParens->MatchingParen || |
| !LeftOfParens->MatchingParen->Previous) |
| return false; |
| LeftOfParens = LeftOfParens->MatchingParen->Previous; |
| } |
| |
| // If there is an identifier (or with a few exceptions a keyword) right |
| // before the parentheses, this is unlikely to be a cast. |
| if (LeftOfParens->Tok.getIdentifierInfo() && |
| !LeftOfParens->isOneOf(Keywords.kw_in, tok::kw_return, tok::kw_case, |
| tok::kw_delete)) |
| return false; |
| |
| // Certain other tokens right before the parentheses are also signals that |
| // this cannot be a cast. |
| if (LeftOfParens->isOneOf(tok::at, tok::r_square, TT_OverloadedOperator, |
| TT_TemplateCloser, tok::ellipsis)) |
| return false; |
| } |
| |
| if (Tok.Next->is(tok::question)) |
| return false; |
| |
| // `foreach((A a, B b) in someList)` should not be seen as a cast. |
| if (Tok.Next->is(Keywords.kw_in) && Style.isCSharp()) |
| return false; |
| |
| // Functions which end with decorations like volatile, noexcept are unlikely |
| // to be casts. |
| if (Tok.Next->isOneOf(tok::kw_noexcept, tok::kw_volatile, tok::kw_const, |
| tok::kw_requires, tok::kw_throw, tok::arrow, |
| Keywords.kw_override, Keywords.kw_final) || |
| isCpp11AttributeSpecifier(*Tok.Next)) |
| return false; |
| |
| // As Java has no function types, a "(" after the ")" likely means that this |
| // is a cast. |
| if (Style.Language == FormatStyle::LK_Java && Tok.Next->is(tok::l_paren)) |
| return true; |
| |
| // If a (non-string) literal follows, this is likely a cast. |
| if (Tok.Next->isNot(tok::string_literal) && |
| (Tok.Next->Tok.isLiteral() || |
| Tok.Next->isOneOf(tok::kw_sizeof, tok::kw_alignof))) |
| return true; |
| |
| // Heuristically try to determine whether the parentheses contain a type. |
| auto IsQualifiedPointerOrReference = [](FormatToken *T) { |
| // This is used to handle cases such as x = (foo *const)&y; |
| assert(!T->isSimpleTypeSpecifier() && "Should have already been checked"); |
| // Strip trailing qualifiers such as const or volatile when checking |
| // whether the parens could be a cast to a pointer/reference type. |
| while (T) { |
| if (T->is(TT_AttributeParen)) { |
| // Handle `x = (foo *__attribute__((foo)))&v;`: |
| if (T->MatchingParen && T->MatchingParen->Previous && |
| T->MatchingParen->Previous->is(tok::kw___attribute)) { |
| T = T->MatchingParen->Previous->Previous; |
| continue; |
| } |
| } else if (T->is(TT_AttributeSquare)) { |
| // Handle `x = (foo *[[clang::foo]])&v;`: |
| if (T->MatchingParen && T->MatchingParen->Previous) { |
| T = T->MatchingParen->Previous; |
| continue; |
| } |
| } else if (T->canBePointerOrReferenceQualifier()) { |
| T = T->Previous; |
| continue; |
| } |
| break; |
| } |
| return T && T->is(TT_PointerOrReference); |
| }; |
| bool ParensAreType = |
| !Tok.Previous || |
| Tok.Previous->isOneOf(TT_TemplateCloser, TT_TypeDeclarationParen) || |
| Tok.Previous->isSimpleTypeSpecifier() || |
| IsQualifiedPointerOrReference(Tok.Previous); |
| bool ParensCouldEndDecl = |
| Tok.Next->isOneOf(tok::equal, tok::semi, tok::l_brace, tok::greater); |
| if (ParensAreType && !ParensCouldEndDecl) |
| return true; |
| |
| // At this point, we heuristically assume that there are no casts at the |
| // start of the line. We assume that we have found most cases where there |
| // are by the logic above, e.g. "(void)x;". |
| if (!LeftOfParens) |
| return false; |
| |
| // Certain token types inside the parentheses mean that this can't be a |
| // cast. |
| for (const FormatToken *Token = Tok.MatchingParen->Next; Token != &Tok; |
| Token = Token->Next) |
| if (Token->is(TT_BinaryOperator)) |
| return false; |
| |
| // If the following token is an identifier or 'this', this is a cast. All |
| // cases where this can be something else are handled above. |
| if (Tok.Next->isOneOf(tok::identifier, tok::kw_this)) |
| return true; |
| |
| // Look for a cast `( x ) (`. |
| if (Tok.Next->is(tok::l_paren) && Tok.Previous && Tok.Previous->Previous) { |
| if (Tok.Previous->is(tok::identifier) && |
| Tok.Previous->Previous->is(tok::l_paren)) |
| return true; |
| } |
| |
| if (!Tok.Next->Next) |
| return false; |
| |
| // If the next token after the parenthesis is a unary operator, assume |
| // that this is cast, unless there are unexpected tokens inside the |
| // parenthesis. |
| bool NextIsUnary = |
| Tok.Next->isUnaryOperator() || Tok.Next->isOneOf(tok::amp, tok::star); |
| if (!NextIsUnary || Tok.Next->is(tok::plus) || |
| !Tok.Next->Next->isOneOf(tok::identifier, tok::numeric_constant)) |
| return false; |
| // Search for unexpected tokens. |
| for (FormatToken *Prev = Tok.Previous; Prev != Tok.MatchingParen; |
| Prev = Prev->Previous) { |
| if (!Prev->isOneOf(tok::kw_const, tok::identifier, tok::coloncolon)) |
| return false; |
| } |
| return true; |
| } |
| |
| /// Return the type of the given token assuming it is * or &. |
| TokenType determineStarAmpUsage(const FormatToken &Tok, bool IsExpression, |
| bool InTemplateArgument) { |
| if (Style.Language == FormatStyle::LK_JavaScript) |
| return TT_BinaryOperator; |
| |
| // && in C# must be a binary operator. |
| if (Style.isCSharp() && Tok.is(tok::ampamp)) |
| return TT_BinaryOperator; |
| |
| const FormatToken *PrevToken = Tok.getPreviousNonComment(); |
| if (!PrevToken) |
| return TT_UnaryOperator; |
| |
| const FormatToken *NextToken = Tok.getNextNonComment(); |
| if (!NextToken || |
| NextToken->isOneOf(tok::arrow, tok::equal, tok::kw_noexcept) || |
| NextToken->canBePointerOrReferenceQualifier() || |
| (NextToken->is(tok::l_brace) && !NextToken->getNextNonComment())) |
| return TT_PointerOrReference; |
| |
| if (PrevToken->is(tok::coloncolon)) |
| return TT_PointerOrReference; |
| |
| if (PrevToken->is(tok::r_paren) && PrevToken->is(TT_TypeDeclarationParen)) |
| return TT_PointerOrReference; |
| |
| if (PrevToken->isOneOf(tok::l_paren, tok::l_square, tok::l_brace, |
| tok::comma, tok::semi, tok::kw_return, tok::colon, |
| tok::kw_co_return, tok::kw_co_await, |
| tok::kw_co_yield, tok::equal, tok::kw_delete, |
| tok::kw_sizeof, tok::kw_throw) || |
| PrevToken->isOneOf(TT_BinaryOperator, TT_ConditionalExpr, |
| TT_UnaryOperator, TT_CastRParen)) |
| return TT_UnaryOperator; |
| |
| if (NextToken->is(tok::l_square) && NextToken->isNot(TT_LambdaLSquare)) |
| return TT_PointerOrReference; |
| if (NextToken->is(tok::kw_operator) && !IsExpression) |
| return TT_PointerOrReference; |
| if (NextToken->isOneOf(tok::comma, tok::semi)) |
| return TT_PointerOrReference; |
| |
| if (PrevToken->Tok.isLiteral() || |
| PrevToken->isOneOf(tok::r_paren, tok::r_square, tok::kw_true, |
| tok::kw_false, tok::r_brace) || |
| NextToken->Tok.isLiteral() || |
| NextToken->isOneOf(tok::kw_true, tok::kw_false) || |
| NextToken->isUnaryOperator() || |
| // If we know we're in a template argument, there are no named |
| // declarations. Thus, having an identifier on the right-hand side |
| // indicates a binary operator. |
| (InTemplateArgument && NextToken->Tok.isAnyIdentifier())) |
| return TT_BinaryOperator; |
| |
| // "&&(" is quite unlikely to be two successive unary "&". |
| if (Tok.is(tok::ampamp) && NextToken->is(tok::l_paren)) |
| return TT_BinaryOperator; |
| |
| // This catches some cases where evaluation order is used as control flow: |
| // aaa && aaa->f(); |
| if (NextToken->Tok.isAnyIdentifier()) { |
| const FormatToken *NextNextToken = NextToken->getNextNonComment(); |
| if (NextNextToken && NextNextToken->is(tok::arrow)) |
| return TT_BinaryOperator; |
| } |
| |
| // It is very unlikely that we are going to find a pointer or reference type |
| // definition on the RHS of an assignment. |
| if (IsExpression && !Contexts.back().CaretFound) |
| return TT_BinaryOperator; |
| |
| return TT_PointerOrReference; |
| } |
| |
| TokenType determinePlusMinusCaretUsage(const FormatToken &Tok) { |
| const FormatToken *PrevToken = Tok.getPreviousNonComment(); |
| if (!PrevToken) |
| return TT_UnaryOperator; |
| |
| if (PrevToken->isOneOf(TT_CastRParen, TT_UnaryOperator)) |
| // This must be a sequence of leading unary operators. |
| return TT_UnaryOperator; |
| |
| // Use heuristics to recognize unary operators. |
| if (PrevToken->isOneOf(tok::equal, tok::l_paren, tok::comma, tok::l_square, |
| tok::question, tok::colon, tok::kw_return, |
| tok::kw_case, tok::at, tok::l_brace, tok::kw_throw, |
| tok::kw_co_return, tok::kw_co_yield)) |
| return TT_UnaryOperator; |
| |
| // There can't be two consecutive binary operators. |
| if (PrevToken->is(TT_BinaryOperator)) |
| return TT_UnaryOperator; |
| |
| // Fall back to marking the token as binary operator. |
| return TT_BinaryOperator; |
| } |
| |
| /// Determine whether ++/-- are pre- or post-increments/-decrements. |
| TokenType determineIncrementUsage(const FormatToken &Tok) { |
| const FormatToken *PrevToken = Tok.getPreviousNonComment(); |
| if (!PrevToken || PrevToken->is(TT_CastRParen)) |
| return TT_UnaryOperator; |
| if (PrevToken->isOneOf(tok::r_paren, tok::r_square, tok::identifier)) |
| return TT_TrailingUnaryOperator; |
| |
| return TT_UnaryOperator; |
| } |
| |
| SmallVector<Context, 8> Contexts; |
| |
| const FormatStyle &Style; |
| AnnotatedLine &Line; |
| FormatToken *CurrentToken; |
| bool AutoFound; |
| const AdditionalKeywords &Keywords; |
| |
| // Set of "<" tokens that do not open a template parameter list. If parseAngle |
| // determines that a specific token can't be a template opener, it will make |
| // same decision irrespective of the decisions for tokens leading up to it. |
| // Store this information to prevent this from causing exponential runtime. |
| llvm::SmallPtrSet<FormatToken *, 16> NonTemplateLess; |
| }; |
| |
| static const int PrecedenceUnaryOperator = prec::PointerToMember + 1; |
| static const int PrecedenceArrowAndPeriod = prec::PointerToMember + 2; |
| |
| /// Parses binary expressions by inserting fake parenthesis based on |
| /// operator precedence. |
| class ExpressionParser { |
| public: |
| ExpressionParser(const FormatStyle &Style, const AdditionalKeywords &Keywords, |
| AnnotatedLine &Line) |
| : Style(Style), Keywords(Keywords), Current(Line.First) {} |
| |
| /// Parse expressions with the given operator precedence. |
| void parse(int Precedence = 0) { |
| // Skip 'return' and ObjC selector colons as they are not part of a binary |
| // expression. |
| while (Current && (Current->is(tok::kw_return) || |
| (Current->is(tok::colon) && |
| Current->isOneOf(TT_ObjCMethodExpr, TT_DictLiteral)))) |
| next(); |
| |
| if (!Current || Precedence > PrecedenceArrowAndPeriod) |
| return; |
| |
| // Conditional expressions need to be parsed separately for proper nesting. |
| if (Precedence == prec::Conditional) { |
| parseConditionalExpr(); |
| return; |
| } |
| |
| // Parse unary operators, which all have a higher precedence than binary |
| // operators. |
| if (Precedence == PrecedenceUnaryOperator) { |
| parseUnaryOperator(); |
| return; |
| } |
| |
| FormatToken *Start = Current; |
| FormatToken *LatestOperator = nullptr; |
| unsigned OperatorIndex = 0; |
| |
| while (Current) { |
| // Consume operators with higher precedence. |
| parse(Precedence + 1); |
| |
| int CurrentPrecedence = getCurrentPrecedence(); |
| |
| if (Current && Current->is(TT_SelectorName) && |
| Precedence == CurrentPrecedence) { |
| if (LatestOperator) |
| addFakeParenthesis(Start, prec::Level(Precedence)); |
| Start = Current; |
| } |
| |
| // At the end of the line or when an operator with higher precedence is |
| // found, insert fake parenthesis and return. |
| if (!Current || |
| (Current->closesScope() && |
| (Current->MatchingParen || Current->is(TT_TemplateString))) || |
| (CurrentPrecedence != -1 && CurrentPrecedence < Precedence) || |
| (CurrentPrecedence == prec::Conditional && |
| Precedence == prec::Assignment && Current->is(tok::colon))) { |
| break; |
| } |
| |
| // Consume scopes: (), [], <> and {} |
| if (Current->opensScope()) { |
| // In fragment of a JavaScript template string can look like '}..${' and |
| // thus close a scope and open a new one at the same time. |
| while (Current && (!Current->closesScope() || Current->opensScope())) { |
| next(); |
| parse(); |
| } |
| next(); |
| } else { |
| // Operator found. |
| if (CurrentPrecedence == Precedence) { |
| if (LatestOperator) |
| LatestOperator->NextOperator = Current; |
| LatestOperator = Current; |
| Current->OperatorIndex = OperatorIndex; |
| ++OperatorIndex; |
| } |
| next(/*SkipPastLeadingComments=*/Precedence > 0); |
| } |
| } |
| |
| if (LatestOperator && (Current || Precedence > 0)) { |
| // LatestOperator->LastOperator = true; |
| if (Precedence == PrecedenceArrowAndPeriod) { |
| // Call expressions don't have a binary operator precedence. |
| addFakeParenthesis(Start, prec::Unknown); |
| } else { |
| addFakeParenthesis(Start, prec::Level(Precedence)); |
| } |
| } |
| } |
| |
| private: |
| /// Gets the precedence (+1) of the given token for binary operators |
| /// and other tokens that we treat like binary operators. |
| int getCurrentPrecedence() { |
| if (Current) { |
| const FormatToken *NextNonComment = Current->getNextNonComment(); |
| if (Current->is(TT_ConditionalExpr)) |
| return prec::Conditional; |
| if (NextNonComment && Current->is(TT_SelectorName) && |
| (NextNonComment->isOneOf(TT_DictLiteral, TT_JsTypeColon) || |
| ((Style.Language == FormatStyle::LK_Proto || |
| Style.Language == FormatStyle::LK_TextProto) && |
| NextNonComment->is(tok::less)))) |
| return prec::Assignment; |
| if (Current->is(TT_JsComputedPropertyName)) |
| return prec::Assignment; |
| if (Current->is(TT_LambdaArrow)) |
| return prec::Comma; |
| if (Current->is(TT_FatArrow)) |
| return prec::Assignment; |
| if (Current->isOneOf(tok::semi, TT_InlineASMColon, TT_SelectorName) || |
| (Current->is(tok::comment) && NextNonComment && |
| NextNonComment->is(TT_SelectorName))) |
| return 0; |
| if (Current->is(TT_RangeBasedForLoopColon)) |
| return prec::Comma; |
| if ((Style.Language == FormatStyle::LK_Java || |
| Style.Language == FormatStyle::LK_JavaScript) && |
| Current->is(Keywords.kw_instanceof)) |
| return prec::Relational; |
| if (Style.Language == FormatStyle::LK_JavaScript && |
| Current->isOneOf(Keywords.kw_in, Keywords.kw_as)) |
| return prec::Relational; |
| if (Current->is(TT_BinaryOperator) || Current->is(tok::comma)) |
| return Current->getPrecedence(); |
| if (Current->isOneOf(tok::period, tok::arrow)) |
| return PrecedenceArrowAndPeriod; |
| if ((Style.Language == FormatStyle::LK_Java || |
| Style.Language == FormatStyle::LK_JavaScript) && |
| Current->isOneOf(Keywords.kw_extends, Keywords.kw_implements, |
| Keywords.kw_throws)) |
| return 0; |
| } |
| return -1; |
| } |
| |
| void addFakeParenthesis(FormatToken *Start, prec::Level Precedence) { |
| Start->FakeLParens.push_back(Precedence); |
| if (Precedence > prec::Unknown) |
| Start->StartsBinaryExpression = true; |
| if (Current) { |
| FormatToken *Previous = Current->Previous; |
| while (Previous->is(tok::comment) && Previous->Previous) |
| Previous = Previous->Previous; |
| ++Previous->FakeRParens; |
| if (Precedence > prec::Unknown) |
| Previous->EndsBinaryExpression = true; |
| } |
| } |
| |
| /// Parse unary operator expressions and surround them with fake |
| /// parentheses if appropriate. |
| void parseUnaryOperator() { |
| llvm::SmallVector<FormatToken *, 2> Tokens; |
| while (Current && Current->is(TT_UnaryOperator)) { |
| Tokens.push_back(Current); |
| next(); |
| } |
| parse(PrecedenceArrowAndPeriod); |
| for (FormatToken *Token : llvm::reverse(Tokens)) |
| // The actual precedence doesn't matter. |
| addFakeParenthesis(Token, prec::Unknown); |
| } |
| |
| void parseConditionalExpr() { |
| while (Current && Current->isTrailingComment()) { |
| next(); |
| } |
| FormatToken *Start = Current; |
| parse(prec::LogicalOr); |
| if (!Current || !Current->is(tok::question)) |
| return; |
| next(); |
| parse(prec::Assignment); |
| if (!Current || Current->isNot(TT_ConditionalExpr)) |
| return; |
| next(); |
| parse(prec::Assignment); |
| addFakeParenthesis(Start, prec::Conditional); |
| } |
| |
| void next(bool SkipPastLeadingComments = true) { |
| if (Current) |
| Current = Current->Next; |
| while (Current && |
| (Current->NewlinesBefore == 0 || SkipPastLeadingComments) && |
| Current->isTrailingComment()) |
| Current = Current->Next; |
| } |
| |
| const FormatStyle &Style; |
| const AdditionalKeywords &Keywords; |
| FormatToken *Current; |
| }; |
| |
| } // end anonymous namespace |
| |
| void TokenAnnotator::setCommentLineLevels( |
| SmallVectorImpl<AnnotatedLine *> &Lines) { |
| const AnnotatedLine *NextNonCommentLine = nullptr; |
| for (AnnotatedLine *AL : llvm::reverse(Lines)) { |
| bool CommentLine = true; |
| for (const FormatToken *Tok = AL->First; Tok; Tok = Tok->Next) { |
| if (!Tok->is(tok::comment)) { |
| CommentLine = false; |
| break; |
| } |
| } |
| |
| // If the comment is currently aligned with the line immediately following |
| // it, that's probably intentional and we should keep it. |
| if (NextNonCommentLine && CommentLine && |
| NextNonCommentLine->First->NewlinesBefore <= 1 && |
| NextNonCommentLine->First->OriginalColumn == |
| AL->First->OriginalColumn) { |
| // Align comments for preprocessor lines with the # in column 0 if |
| // preprocessor lines are not indented. Otherwise, align with the next |
| // line. |
| AL->Level = (Style.IndentPPDirectives != FormatStyle::PPDIS_BeforeHash && |
| (NextNonCommentLine->Type == LT_PreprocessorDirective || |
| NextNonCommentLine->Type == LT_ImportStatement)) |
| ? 0 |
| : NextNonCommentLine->Level; |
| } else { |
| NextNonCommentLine = AL->First->isNot(tok::r_brace) ? AL : nullptr; |
| } |
| |
| setCommentLineLevels(AL->Children); |
| } |
| } |
| |
| static unsigned maxNestingDepth(const AnnotatedLine &Line) { |
| unsigned Result = 0; |
| for (const auto *Tok = Line.First; Tok != nullptr; Tok = Tok->Next) |
| Result = std::max(Result, Tok->NestingLevel); |
| return Result; |
| } |
| |
| void TokenAnnotator::annotate(AnnotatedLine &Line) { |
| for (SmallVectorImpl<AnnotatedLine *>::iterator I = Line.Children.begin(), |
| E = Line.Children.end(); |
| I != E; ++I) { |
| annotate(**I); |
| } |
| AnnotatingParser Parser(Style, Line, Keywords); |
| Line.Type = Parser.parseLine(); |
| |
| // With very deep nesting, ExpressionParser uses lots of stack and the |
| // formatting algorithm is very slow. We're not going to do a good job here |
| // anyway - it's probably generated code being formatted by mistake. |
| // Just skip the whole line. |
| if (maxNestingDepth(Line) > 50) |
| Line.Type = LT_Invalid; |
| |
| if (Line.Type == LT_Invalid) |
| return; |
| |
| ExpressionParser ExprParser(Style, Keywords, Line); |
| ExprParser.parse(); |
| |
| if (Line.startsWith(TT_ObjCMethodSpecifier)) |
| Line.Type = LT_ObjCMethodDecl; |
| else if (Line.startsWith(TT_ObjCDecl)) |
| Line.Type = LT_ObjCDecl; |
| else if (Line.startsWith(TT_ObjCProperty)) |
| Line.Type = LT_ObjCProperty; |
| |
| Line.First->SpacesRequiredBefore = 1; |
| Line.First->CanBreakBefore = Line.First->MustBreakBefore; |
| } |
| |
| // This function heuristically determines whether 'Current' starts the name of a |
| // function declaration. |
| static bool isFunctionDeclarationName(bool IsCpp, const FormatToken &Current, |
| const AnnotatedLine &Line) { |
| auto skipOperatorName = [](const FormatToken *Next) -> const FormatToken * { |
| for (; Next; Next = Next->Next) { |
| if (Next->is(TT_OverloadedOperatorLParen)) |
| return Next; |
| if (Next->is(TT_OverloadedOperator)) |
| continue; |
| if (Next->isOneOf(tok::kw_new, tok::kw_delete)) { |
| // For 'new[]' and 'delete[]'. |
| if (Next->Next && |
| Next->Next->startsSequence(tok::l_square, tok::r_square)) |
| Next = Next->Next->Next; |
| continue; |
| } |
| if (Next->startsSequence(tok::l_square, tok::r_square)) { |
| // For operator[](). |
| Next = Next->Next; |
| continue; |
| } |
| if ((Next->isSimpleTypeSpecifier() || Next->is(tok::identifier)) && |
| Next->Next && Next->Next->isOneOf(tok::star, tok::amp, tok::ampamp)) { |
| // For operator void*(), operator char*(), operator Foo*(). |
| Next = Next->Next; |
| continue; |
| } |
| if (Next->is(TT_TemplateOpener) && Next->MatchingParen) { |
| Next = Next->MatchingParen; |
| continue; |
| } |
| |
| break; |
| } |
| return nullptr; |
| }; |
| |
| // Find parentheses of parameter list. |
| const FormatToken *Next = Current.Next; |
| if (Current.is(tok::kw_operator)) { |
| if (Current.Previous && Current.Previous->is(tok::coloncolon)) |
| return false; |
| Next = skipOperatorName(Next); |
| } else { |
| if (!Current.is(TT_StartOfName) || Current.NestingLevel != 0) |
| return false; |
| for (; Next; Next = Next->Next) { |
| if (Next->is(TT_TemplateOpener)) { |
| Next = Next->MatchingParen; |
| } else if (Next->is(tok::coloncolon)) { |
| Next = Next->Next; |
| if (!Next) |
| return false; |
| if (Next->is(tok::kw_operator)) { |
| Next = skipOperatorName(Next->Next); |
| break; |
| } |
| if (!Next->is(tok::identifier)) |
| return false; |
| } else if (Next->is(tok::l_paren)) { |
| break; |
| } else { |
| return false; |
| } |
| } |
| } |
| |
| // Check whether parameter list can belong to a function declaration. |
| if (!Next || !Next->is(tok::l_paren) || !Next->MatchingParen) |
| return false; |
| // If the lines ends with "{", this is likely a function definition. |
| if (Line.Last->is(tok::l_brace)) |
| return true; |
| if (Next->Next == Next->MatchingParen) |
| return true; // Empty parentheses. |
| // If there is an &/&& after the r_paren, this is likely a function. |
| if (Next->MatchingParen->Next && |
| Next->MatchingParen->Next->is(TT_PointerOrReference)) |
| return true; |
| |
| // Check for K&R C function definitions (and C++ function definitions with |
| // unnamed parameters), e.g.: |
| // int f(i) |
| // { |
| // return i + 1; |
| // } |
| // bool g(size_t = 0, bool b = false) |
| // { |
| // return !b; |
| // } |
| if (IsCpp && Next->Next && Next->Next->is(tok::identifier) && |
| !Line.endsWith(tok::semi)) |
| return true; |
| |
| for (const FormatToken *Tok = Next->Next; Tok && Tok != Next->MatchingParen; |
| Tok = Tok->Next) { |
| if (Tok->is(TT_TypeDeclarationParen)) |
| return true; |
| if (Tok->isOneOf(tok::l_paren, TT_TemplateOpener) && Tok->MatchingParen) { |
| Tok = Tok->MatchingParen; |
| continue; |
| } |
|