maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/lib/Format/TokenAnnotator.cpp

3302 lines
133 KiB
C++
Raw Normal View History

Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
//===--- TokenAnnotator.cpp - Format C++ code -----------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
///
/// \file
Remove \brief commands from doxygen comments. This is similar to the LLVM change https://reviews.llvm.org/D46290. We've been running doxygen with the autobrief option for a couple of years now. This makes the \brief markers into our comments redundant. Since they are a visual distraction and we don't want to encourage more \brief markers in new code either, this patch removes them all. Patch produced by for i in $(git grep -l '\@brief'); do perl -pi -e 's/\@brief //g' $i & done for i in $(git grep -l '\\brief'); do perl -pi -e 's/\\brief //g' $i & done Differential Revision: https://reviews.llvm.org/D46320 llvm-svn: 331834
2018-05-09 09:00:01 +08:00
/// This file implements a token annotator, i.e. creates
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
/// \c AnnotatedTokens out of \c FormatTokens with required extra information.
///
//===----------------------------------------------------------------------===//
#include "TokenAnnotator.h"
#include "clang/Basic/SourceManager.h"
clang-format: Prevent exponential runtime in token annotator. llvm-svn: 236577
2015-05-06 16:38:24 +08:00
#include "llvm/ADT/SmallPtrSet.h"
Revamp indentation behavior for complex binary expressions. The idea is to indent according to operator precedence and pretty much identical to how stuff would be indented with parenthesis. Before: bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa > ccccccccccccccccccccccccccccccccccccccccc; After: bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa > ccccccccccccccccccccccccccccccccccccccccc; llvm-svn: 179049
2013-04-09 04:33:42 +08:00
#include "llvm/Support/Debug.h"
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
[Modules] Update Clang's two files that use DEBUG(...) without defining DEBUG_TYPE to do so. LLVM's Debug.h requires this as of r206822. llvm-svn: 206823
2014-04-22 06:55:36 +08:00
#define DEBUG_TYPE "format-token-annotator"
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
namespace clang {
namespace format {
Put helper classes in an anonymous namespace. llvm-svn: 185301
2013-07-01 12:03:19 +08:00
namespace {
Remove \brief commands from doxygen comments. This is similar to the LLVM change https://reviews.llvm.org/D46290. We've been running doxygen with the autobrief option for a couple of years now. This makes the \brief markers into our comments redundant. Since they are a visual distraction and we don't want to encourage more \brief markers in new code either, this patch removes them all. Patch produced by for i in $(git grep -l '\@brief'); do perl -pi -e 's/\@brief //g' $i & done for i in $(git grep -l '\\brief'); do perl -pi -e 's/\\brief //g' $i & done Differential Revision: https://reviews.llvm.org/D46320 llvm-svn: 331834
2018-05-09 09:00:01 +08:00
/// Returns \c true if the token can be used as an identifier in
[clang-format/ObjC] Use getIdentifierInfo() instead of tok::identifier Summary: Previously, we checked tokens for `tok::identifier` to see if they were identifiers inside an Objective-C selector. However, this missed C++ keywords like `new` and `delete`. To fix this, this diff uses `getIdentifierInfo()` to find identifiers or keywords inside Objective-C selectors. Test Plan: New tests added. Ran tests with: % make -j16 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: djasper, jolesiak Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D46143 llvm-svn: 331067
2018-04-28 02:51:12 +08:00
/// 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;
}
Remove \brief commands from doxygen comments. This is similar to the LLVM change https://reviews.llvm.org/D46290. We've been running doxygen with the autobrief option for a couple of years now. This makes the \brief markers into our comments redundant. Since they are a visual distraction and we don't want to encourage more \brief markers in new code either, this patch removes them all. Patch produced by for i in $(git grep -l '\@brief'); do perl -pi -e 's/\@brief //g' $i & done for i in $(git grep -l '\\brief'); do perl -pi -e 's/\\brief //g' $i & done Differential Revision: https://reviews.llvm.org/D46320 llvm-svn: 331834
2018-05-09 09:00:01 +08:00
/// A parser that gathers additional information about tokens.
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
///
Implemented formatting of rvalue references Summary: Handle "&&" usage as rvalue reference, added tests and fixed incorrect tests that interfere with this feature. http://llvm.org/bugs/show_bug.cgi?id=15051 Reviewers: djasper Reviewed By: djasper CC: cfe-commits, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D531 llvm-svn: 176874
2013-03-13 00:28:18 +08:00
/// The \c TokenAnnotator tries to match parenthesis and square brakets and
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
/// store a parenthesis levels. It also tries to resolve matching "<" and ">"
/// into template parameter lists.
class AnnotatingParser {
public:
clang-format: Add column layout formatting for braced lists With this patch, braced lists (with more than 3 elements are formatted in a column layout if possible). E.g.: static const uint16_t CallerSavedRegs64Bit[] = { X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI, X86::R8, X86::R9, X86::R10, X86::R11, 0 }; Required other changes: - FormatTokens can now have a special role that contains extra data and can do special formattings. A comma separated list is currently the only implementation. - Move penalty calculation entirely into ContinuationIndenter (there was a last piece still in UnwrappedLineFormatter). Review: http://llvm-reviews.chandlerc.com/D1457 llvm-svn: 189018
2013-08-22 23:00:41 +08:00
AnnotatingParser(const FormatStyle &Style, AnnotatedLine &Line,
clang-format: Use identifier table for keywords in other languages. Slightly easier to write, more efficient and prevents bugs by misspelling them. No functional changes intended. llvm-svn: 221259
2014-11-04 20:41:02 +08:00
const AdditionalKeywords &Keywords)
clang-format: [JS] Support Closure's module statements. These are like import statements and should not be line-wrapped. Minor restructuring of the handling of other import statements. llvm-svn: 222637
2014-11-24 00:46:28 +08:00
: Style(Style), Line(Line), CurrentToken(Line.First), AutoFound(false),
Keywords(Keywords) {
Run clang-format on lib/Format code after r184894. No other changes. llvm-svn: 184896
2013-06-26 08:30:14 +08:00
Contexts.push_back(Context(tok::unknown, 1, /*IsExpression=*/false));
Fix crasher bug. Due to not resetting the fake rparen data on the token when iterating over annotated lines, we would pop the last element of the paren stack. This patch fixes the underlying root cause, and makes the code more robust against similar problems in the future: - reset the first token when iterating on the same annotated lines due to preprocessor branches - never pop the last element from the paren stack, so we do not crash, but rather incorrectly format - add assert()s so we can figure out if our assumptions are violated llvm-svn: 204140
2014-03-18 19:22:45 +08:00
resetTokenMetadata(CurrentToken);
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
}
Formatter: Correctly format stars in `sizeof(int**)` and similar places. This redoes how '*' and '&' are classified as pointer / reference markers when followed by ')', '>', or ','. Previously, determineStarAmpUsage() marked a single '*' and '&' followed by ')', '>', or ',' as pointer or reference marker. Now, all '*'s and '&'s preceding ')', '>', or ',' are marked as pointer / reference markers. Fixes PR14884. Since only the last '*' in 'int ***' was marked as pointer before (the rest were unary operators, which don't reach spaceRequiredBetween()), spaceRequiredBetween() now had to be thought about handing multiple '*'s in sequence. Before: return sizeof(int * *); Type **A = static_cast<Type * *>(P); Now: return sizeof(int**); Type **A = static_cast<Type **>(P); While here, also make all methods of AnnotatingParser except parseLine() private. Review URL: http://llvm-reviews.chandlerc.com/D384 llvm-svn: 174975
2013-02-13 00:17:07 +08:00
private:
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
bool parseAngle() {
clang-format: Fix corner case in template detection. Before: f(a.operator() < A > ()); After: f(a.operator()<A>()); llvm-svn: 259884
2016-02-05 22:17:16 +08:00
if (!CurrentToken || !CurrentToken->Previous)
return false;
if (NonTemplateLess.count(CurrentToken->Previous))
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return false;
clang-format: Fix corner case in template detection. Before: f(a.operator() < A > ()); After: f(a.operator()<A>()); llvm-svn: 259884
2016-02-05 22:17:16 +08:00
clang-format/java: Unbreak genenrics formatting after r299952. https://reviews.llvm.org/rL299952 merged '>>>' tokens into a single JavaRightLogicalShift token. This broke formatting of generics nested more than two deep, e.g. Foo<Bar<Baz>>> because the '>>>' now weren't three '>' for parseAngle(). Luckily, just deleting JavaRightLogicalShift fixes things without breaking the test added in r299952, so do that. https://reviews.llvm.org/D38291 llvm-svn: 314325
2017-09-28 01:57:50 +08:00
const FormatToken &Previous = *CurrentToken->Previous; // The '<'.
clang-format: Fix corner case in template detection. Before: f(a.operator() < A > ()); After: f(a.operator()<A>()); llvm-svn: 259884
2016-02-05 22:17:16 +08:00
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;
}
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
FormatToken *Left = CurrentToken->Previous;
clang-format: Force aligning different brackets relative to each other. Before: void SomeFunction(vector< // break int> v); After: void SomeFunction(vector< // break int> v); llvm-svn: 236412
2015-05-04 15:39:00 +08:00
Left->ParentBracket = Contexts.back().ContextKind;
clang-format: Make it more expensive to break template parameters. In particular, make it more expensive than breaking after the return type of a function definition/declaration. Before: template <typename T> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaa< T>::aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa); After: template <typename T> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa( aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa); llvm-svn: 260497
2016-02-11 14:43:01 +08:00
ScopedContextCreator ContextCreator(*this, tok::less, 12);
clang-format: Allow ternary expressions inside template parameters if the template parameters aren't inside an expression context. This fixes llvm.org/PR23270. llvm-svn: 236603
2015-05-06 22:53:50 +08:00
// If this angle is in the context of an expression, we need to be more
clang-format: Improve r236597, Properly indent method calls without inputs. Before: [aaaaaaaaaaaa(aaaaaa) aaaaaaaaaaaaaaaaaaaa]; After: [aaaaaaaaaaaa(aaaaaa) aaaaaaaaaaaaaaaaaaaa]; llvm-svn: 236730
2015-05-07 22:19:59 +08:00
// hesitant to detect it as opening template parameters.
clang-format: Allow ternary expressions inside template parameters if the template parameters aren't inside an expression context. This fixes llvm.org/PR23270. llvm-svn: 236603
2015-05-06 22:53:50 +08:00
bool InExprContext = Contexts.back().IsExpression;
Handle nested ObjC calls. Properly handle annotation contexts while calculating extra information for each token. This enable nested ObjC calls and thus solves (most of) llvm.org/PR15164. E.g., we can now format: [contentsContainer replaceSubview:[subviews objectAtIndex:0] with:contentsNativeView]; Also fix a problem with the formatting of types in casts as this was trivial now. llvm-svn: 174498
2013-02-06 18:05:46 +08:00
Contexts.back().IsExpression = false;
Fix bool expression special case. Clang-format now correctly formats: some_type<a * b> v; template <bool a, bool b> typename enabled_if<a && b>::type f() {} llvm-svn: 204913
2014-03-27 19:17:36 +08:00
// If there's a template keyword before the opening angle bracket, this is a
// template parameter, not an argument.
Contexts.back().InTemplateArgument =
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
Left->Previous && Left->Previous->Tok.isNot(tok::kw_template);
Fix bool expression special case. Clang-format now correctly formats: some_type<a * b> v; template <bool a, bool b> typename enabled_if<a && b>::type f() {} llvm-svn: 204913
2014-03-27 19:17:36 +08:00
clang-format: [Java] Improve generic support. Before: Iterable< ? > a; Iterable< ? extends SomeObject > a; After: Iterable<?> a; Iterable<? extends SomeObject> a; llvm-svn: 220281
2014-10-21 17:57:09 +08:00
if (Style.Language == FormatStyle::LK_Java &&
CurrentToken->is(tok::question))
next();
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
while (CurrentToken) {
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
if (CurrentToken->is(tok::greater)) {
Left->MatchingParen = CurrentToken;
CurrentToken->MatchingParen = Left;
[clang-format] Adds space around angle brackets in text protos Summary: This patch adds spaces around angle brackets in text proto Google style. Previously these were detected as template openers and closers, which happened to have the expected effect. Now we detect them as scope openers and closers similarly to the way braces are handled in this context. Reviewers: djasper Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D42727 llvm-svn: 324337
2018-02-06 19:34:34 +08:00
// 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->Type = TT_DictLiteral;
else
CurrentToken->Type = TT_TemplateCloser;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
next();
return true;
}
clang-format: [Java] Support generics with "?". Before: @Override public Map < String, ? > getAll() { // ... } After: @Override public Map<String, ?> getAll() { // ... } This fixes llvm.org/PR21454. llvm-svn: 221109
2014-11-03 05:52:57 +08:00
if (CurrentToken->is(tok::question) &&
clang-format: [Java] Improve formatting of generics. Before: Function < F, ? extends T > function; After: Function<F, ? extends T> function; llvm-svn: 221976
2014-11-14 16:22:46 +08:00
Style.Language == FormatStyle::LK_Java) {
next();
continue;
}
clang-format: Allow ternary expressions inside template parameters if the template parameters aren't inside an expression context. This fixes llvm.org/PR23270. llvm-svn: 236603
2015-05-06 22:53:50 +08:00
if (CurrentToken->isOneOf(tok::r_paren, tok::r_square, tok::r_brace) ||
[clang-format] Support <>-style proto message fields Summary: This patch adds support for <>-style proto message fields inside proto options. Previously these were wrongly treated as binary operators and as such were working only by chance for a limited number of cases. Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D34621 llvm-svn: 306406
2017-06-27 21:43:07 +08:00
(CurrentToken->isOneOf(tok::colon, tok::question) && InExprContext &&
[clang-format] Support text proto messages Summary: This patch adds support for textual protocol buffer messages. Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek, mgorny Differential Revision: https://reviews.llvm.org/D34441 llvm-svn: 307029
2017-07-03 23:05:14 +08:00
Style.Language != FormatStyle::LK_Proto &&
Style.Language != FormatStyle::LK_TextProto))
Improve recognition of template definitions. In the long run, this will probably be better fixed by a proper expression parser.. Before: template <typename F> Matcher(const Matcher<F> & Other, typename enable_if_c < is_base_of<F, T>::value && !is_same<F, T>::value > ::type * = 0) : Implementation(new ImplicitCastMatcher<F>(Other)) {} After: template <typename F> Matcher(const Matcher<F> & Other, typename enable_if_c<is_base_of<F, T>::value && !is_same<F, T>::value>::type * = 0) : Implementation(new ImplicitCastMatcher<F>(Other)) {} llvm-svn: 181884
2013-05-15 21:46:48 +08:00
return false;
Improve recognition of template parameters. Before: return a<b &&c> d; After: return a < b && c > d; llvm-svn: 183077
2013-06-02 02:56:00 +08:00
// If a && or || is found and interpreted as a binary operator, this set
Let clang-format remove empty lines before "}". These lines almost never aid readability. Before: void f() { int i; // some variable } After: void f() { int i; // some variable } llvm-svn: 183112
2013-06-04 00:16:41 +08:00
// of angles is likely part of something like "a < b && c > d". If the
Improve recognition of template parameters. Before: return a<b &&c> d; After: return a < b && c > d; llvm-svn: 183077
2013-06-02 02:56:00 +08:00
// 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.
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
if (CurrentToken->Previous->isOneOf(tok::pipepipe, tok::ampamp) &&
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
CurrentToken->Previous->is(TT_BinaryOperator) &&
clang-format: Improve operator and template recognition. Before: static_assert(is_convertible < A &&, B > ::value, "AAA"); After: static_assert(is_convertible<A &&, B>::value, "AAA"); llvm-svn: 214075
2014-07-28 21:19:58 +08:00
Contexts[Contexts.size() - 2].IsExpression &&
clang-format: NFC. Add a function to test whether an annotated line starts with a given sequence of tokens. Only the one-token version is used yet, but other usages are coming up momentarily. llvm-svn: 239892
2015-06-17 17:43:56 +08:00
!Line.startsWith(tok::kw_template))
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return false;
Fix counting of parameters so that r175162 works as expected. Before: aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa() .aaaaaaaaaaaaaaaaa()); After: aaaaaaaaaaaaaaaaaaaaaaaaa( aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa()); Not sure which of the formattings above is better, but we should not pick one by accident. llvm-svn: 175165
2013-02-14 23:01:34 +08:00
updateParameterCount(Left, CurrentToken);
[clang-format] Support <>-style proto message fields Summary: This patch adds support for <>-style proto message fields inside proto options. Previously these were wrongly treated as binary operators and as such were working only by chance for a limited number of cases. Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D34621 llvm-svn: 306406
2017-06-27 21:43:07 +08:00
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->Type = TT_SelectorName;
}
}
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
if (!consumeToken())
return false;
}
return false;
}
bool parseParens(bool LookForDecls = false) {
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
if (!CurrentToken)
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return false;
clang-format: Force aligning different brackets relative to each other. Before: void SomeFunction(vector< // break int> v); After: void SomeFunction(vector< // break int> v); llvm-svn: 236412
2015-05-04 15:39:00 +08:00
FormatToken *Left = CurrentToken->Previous;
Left->ParentBracket = Contexts.back().ContextKind;
Basic support for formatting asm() statments. llvm-svn: 177073
2013-03-14 21:45:21 +08:00
ScopedContextCreator ContextCreator(*this, tok::l_paren, 1);
Handle nested ObjC calls. Properly handle annotation contexts while calculating extra information for each token. This enable nested ObjC calls and thus solves (most of) llvm.org/PR15164. E.g., we can now format: [contentsContainer replaceSubview:[subviews objectAtIndex:0] with:contentsNativeView]; Also fix a problem with the formatting of types in casts as this was trivial now. llvm-svn: 174498
2013-02-06 18:05:46 +08:00
// FIXME: This is a bit of a hack. Do better.
Contexts.back().ColonIsForRangeExpr =
Contexts.size() == 2 && Contexts[0].ColonIsForRangeExpr;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
bool StartsObjCMethodExpr = false;
[clang-format] Improve detection of Objective-C block types Summary: Previously, clang-format would detect the following as an Objective-C block type: FOO(^); when it actually must be a C or C++ macro dealing with an XOR statement or an XOR operator overload. According to the Clang Block Language Spec: https://clang.llvm.org/docs/BlockLanguageSpec.html block types are of the form: int (^)(char, float) and block variables of block type are of the form: void (^blockReturningVoidWithVoidArgument)(void); int (^blockReturningIntWithIntAndCharArguments)(int, char); void (^arrayOfTenBlocksReturningVoidWithIntArgument[10])(int); This tightens up the detection so we don't unnecessarily detect C macros which pass in the XOR operator. Depends On D43904 Test Plan: New tests added. Ran tests with: make -j12 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: krasimir, jolesiak, djasper Reviewed By: djasper Subscribers: djasper, cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D43906 llvm-svn: 327285
2018-03-12 23:42:40 +08:00
if (FormatToken *MaybeSel = Left->Previous) {
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
// @selector( starts a selector.
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
if (MaybeSel->isObjCAtKeyword(tok::objc_selector) && MaybeSel->Previous &&
MaybeSel->Previous->is(tok::at)) {
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
StartsObjCMethodExpr = true;
}
}
clang-format: Fix overloading "operator," definitions more thoroughly. Before: aaaaaaaaaaaaaaaaaaaaaa operator,(aaaaaaaaaaaaaaaaaaaaa & aaaaaaaaaaaaaaaaaaaaaaaaaa) const; After: aaaaaaaaaaaaaaaaaaaaaa operator,( aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const; llvm-svn: 257330
2016-01-11 20:55:33 +08:00
if (Left->is(TT_OverloadedOperatorLParen)) {
Contexts.back().IsExpression = false;
clang-format: [JS] recognize more type locations. Summary: Includes parenthesized type expressions and type aliases. Reviewers: djasper Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D21597 llvm-svn: 273603
2016-06-24 03:52:32 +08:00
} else if (Style.Language == FormatStyle::LK_JavaScript &&
clang-format: [JS] recognize exported type definitions. Summary: Support "export type T = {...};", in addition to just "type T = {...};". Reviewers: klimek Differential Revision: https://reviews.llvm.org/D33980 llvm-svn: 304904
2017-06-07 20:53:22 +08:00
(Line.startsWith(Keywords.kw_type, tok::identifier) ||
Line.startsWith(tok::kw_export, Keywords.kw_type,
tok::identifier))) {
clang-format: [JS] recognize more type locations. Summary: Includes parenthesized type expressions and type aliases. Reviewers: djasper Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D21597 llvm-svn: 273603
2016-06-24 03:52:32 +08:00
// type X = (...);
clang-format: [JS] recognize exported type definitions. Summary: Support "export type T = {...};", in addition to just "type T = {...};". Reviewers: klimek Differential Revision: https://reviews.llvm.org/D33980 llvm-svn: 304904
2017-06-07 20:53:22 +08:00
// export type X = (...);
clang-format: [JS] recognize more type locations. Summary: Includes parenthesized type expressions and type aliases. Reviewers: djasper Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D21597 llvm-svn: 273603
2016-06-24 03:52:32 +08:00
Contexts.back().IsExpression = false;
clang-format: Fix overloading "operator," definitions more thoroughly. Before: aaaaaaaaaaaaaaaaaaaaaa operator,(aaaaaaaaaaaaaaaaaaaaa & aaaaaaaaaaaaaaaaaaaaaaaaaa) const; After: aaaaaaaaaaaaaaaaaaaaaa operator,( aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const; llvm-svn: 257330
2016-01-11 20:55:33 +08:00
} else if (Left->Previous &&
clang-format clang-format. llvm-svn: 313744
2017-09-20 17:51:03 +08:00
(Left->Previous->isOneOf(tok::kw_static_assert, tok::kw_decltype,
tok::kw_if, tok::kw_while, tok::l_paren,
tok::comma) ||
Left->Previous->endsSequence(tok::kw_constexpr, tok::kw_if) ||
Left->Previous->is(TT_BinaryOperator))) {
clang-format: Better understand Lambda poarameters. Before: auto PointerBinding = [](const char * S) {}; After: auto PointerBinding = [](const char *S) {}; This fixes llvm.org/PR17618. llvm-svn: 193054
2013-10-21 02:15:30 +08:00
// static_assert, if and while usually contain expressions.
Teach clang-format to understand static_asserts better. Before: template <bool B, bool C> class A { static_assert(B &&C, "Something is wrong"); }; After: template <bool B, bool C> class A { static_assert(B && C, "Something is wrong"); }; (Note the spacing around '&&'). Also change the identifier table to always understand all C++11 keywords (which seems like the right thing to do). llvm-svn: 187589
2013-08-02 01:58:23 +08:00
Contexts.back().IsExpression = true;
clang-format: [JS] no space in union and intersection types. The operators | and & in types, as opposed to the bitwise operators, should not have whitespace around them (e.g. `Foo<Bar|Baz>`). Patch by Martin Probst. Thank you. llvm-svn: 263961
2016-03-22 01:57:31 +08:00
} else if (Style.Language == FormatStyle::LK_JavaScript && Left->Previous &&
clang-format: [JS] recognized named functions in AnnotatingParser. Summary: This also fixes union type formatting in function parameter types. Before: function x(path: number| string) {} After: function x(path: number|string) {} Reviewers: djasper Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D21206 llvm-svn: 272330
2016-06-10 06:49:04 +08:00
(Left->Previous->is(Keywords.kw_function) ||
(Left->Previous->endsSequence(tok::identifier,
Keywords.kw_function)))) {
// function(...) or function f(...)
clang-format: [JS] no space in union and intersection types. The operators | and & in types, as opposed to the bitwise operators, should not have whitespace around them (e.g. `Foo<Bar|Baz>`). Patch by Martin Probst. Thank you. llvm-svn: 263961
2016-03-22 01:57:31 +08:00
Contexts.back().IsExpression = false;
clang-format: [JS] recognize more type locations. Summary: Includes parenthesized type expressions and type aliases. Reviewers: djasper Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D21597 llvm-svn: 273603
2016-06-24 03:52:32 +08:00
} else if (Style.Language == FormatStyle::LK_JavaScript && Left->Previous &&
Left->Previous->is(TT_JsTypeColon)) {
// let x: (SomeType);
Contexts.back().IsExpression = false;
clang-format: Better understand Lambda poarameters. Before: auto PointerBinding = [](const char * S) {}; After: auto PointerBinding = [](const char *S) {}; This fixes llvm.org/PR17618. llvm-svn: 193054
2013-10-21 02:15:30 +08:00
} else if (Left->Previous && Left->Previous->is(tok::r_square) &&
Left->Previous->MatchingParen &&
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
Left->Previous->MatchingParen->is(TT_LambdaLSquare)) {
clang-format: Better understand Lambda poarameters. Before: auto PointerBinding = [](const char * S) {}; After: auto PointerBinding = [](const char *S) {}; This fixes llvm.org/PR17618. llvm-svn: 193054
2013-10-21 02:15:30 +08:00
// This is a parameter list of a lambda expression.
Contexts.back().IsExpression = false;
clang-format: Fix */& detection for lambdas in macros. Before: #define MACRO() [](A * a) { return 1; } After: #define MACRO() [](A *a) { return 1; } llvm-svn: 237109
2015-05-12 18:20:32 +08:00
} else if (Line.InPPDirective &&
clang-format: Fix overloading "operator," definitions more thoroughly. Before: aaaaaaaaaaaaaaaaaaaaaa operator,(aaaaaaaaaaaaaaaaaaaaa & aaaaaaaaaaaaaaaaaaaaaaaaaa) const; After: aaaaaaaaaaaaaaaaaaaaaa operator,( aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const; llvm-svn: 257330
2016-01-11 20:55:33 +08:00
(!Left->Previous || !Left->Previous->is(tok::identifier))) {
clang-format: Fix */& detection for lambdas in macros. Before: #define MACRO() [](A * a) { return 1; } After: #define MACRO() [](A *a) { return 1; } llvm-svn: 237109
2015-05-12 18:20:32 +08:00
Contexts.back().IsExpression = true;
clang-format: Correctly identify ObjC Block with return type. llvm-svn: 204905
2014-03-27 17:43:54 +08:00
} else if (Contexts[Contexts.size() - 2].CaretFound) {
clang-format: Fix various problems in formatting ObjC blocks. Among other things, this fixes llvm.org/PR15269. llvm-svn: 197900
2013-12-23 15:29:06 +08:00
// This is the parameter list of an ObjC block.
Contexts.back().IsExpression = false;
clang-format: Understand __attribute__s preceding parameter lists. Before: ReturnType __attribute__((unused)) function(int i); After: ReturnType __attribute__((unused)) function(int i); This fixes llvm.org/PR18632. llvm-svn: 200337
2014-01-29 04:13:43 +08:00
} else if (Left->Previous && Left->Previous->is(tok::kw___attribute)) {
Left->Type = TT_AttributeParen;
clang-format: NFC: Delete FormatToken::IsForEachMacro. Use a TokenType instead. llvm-svn: 236415
2015-05-04 17:22:29 +08:00
} else if (Left->Previous && Left->Previous->is(TT_ForEachMacro)) {
clang-format: Support configurable list of foreach-macros. This fixes llvm.org/PR17242. Patch by Brian Green, thank you! llvm-svn: 205307
2014-04-01 20:55:11 +08:00
// The first argument to a foreach macro is a declaration.
Contexts.back().IsForEachMacro = true;
Contexts.back().IsExpression = false;
clang-format: [ObjC] Fix spacing in block variable parameters. Before: { void (^block)(Object * x); } After: { void (^block)(Object *x); } llvm-svn: 220270
2014-10-21 15:57:50 +08:00
} else if (Left->Previous && Left->Previous->MatchingParen &&
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
Left->Previous->MatchingParen->is(TT_ObjCBlockLParen)) {
clang-format: [ObjC] Fix spacing in block variable parameters. Before: { void (^block)(Object * x); } After: { void (^block)(Object *x); } llvm-svn: 220270
2014-10-21 15:57:50 +08:00
Contexts.back().IsExpression = false;
clang-format: Fix incorrect function type detection. Before: int x = f (&h)(); After: int x = f(&h)(); llvm-svn: 256488
2015-12-28 15:44:25 +08:00
} else if (!Line.MustBeDeclaration && !Line.InPPDirective) {
bool IsForOrCatch =
Left->Previous && Left->Previous->isOneOf(tok::kw_for, tok::kw_catch);
Contexts.back().IsExpression = !IsForOrCatch;
clang-format: Better understand Lambda poarameters. Before: auto PointerBinding = [](const char * S) {}; After: auto PointerBinding = [](const char *S) {}; This fixes llvm.org/PR17618. llvm-svn: 193054
2013-10-21 02:15:30 +08:00
}
Teach clang-format to understand static_asserts better. Before: template <bool B, bool C> class A { static_assert(B &&C, "Something is wrong"); }; After: template <bool B, bool C> class A { static_assert(B && C, "Something is wrong"); }; (Note the spacing around '&&'). Also change the identifier table to always understand all C++11 keywords (which seems like the right thing to do). llvm-svn: 187589
2013-08-02 01:58:23 +08:00
Handle nested ObjC calls. Properly handle annotation contexts while calculating extra information for each token. This enable nested ObjC calls and thus solves (most of) llvm.org/PR15164. E.g., we can now format: [contentsContainer replaceSubview:[subviews objectAtIndex:0] with:contentsNativeView]; Also fix a problem with the formatting of types in casts as this was trivial now. llvm-svn: 174498
2013-02-06 18:05:46 +08:00
if (StartsObjCMethodExpr) {
Contexts.back().ColonIsObjCMethodExpr = true;
Left->Type = TT_ObjCMethodExpr;
}
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
[clang-format] Improve detection of Objective-C block types Summary: Previously, clang-format would detect the following as an Objective-C block type: FOO(^); when it actually must be a C or C++ macro dealing with an XOR statement or an XOR operator overload. According to the Clang Block Language Spec: https://clang.llvm.org/docs/BlockLanguageSpec.html block types are of the form: int (^)(char, float) and block variables of block type are of the form: void (^blockReturningVoidWithVoidArgument)(void); int (^blockReturningIntWithIntAndCharArguments)(int, char); void (^arrayOfTenBlocksReturningVoidWithIntArgument[10])(int); This tightens up the detection so we don't unnecessarily detect C macros which pass in the XOR operator. Depends On D43904 Test Plan: New tests added. Ran tests with: make -j12 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: krasimir, jolesiak, djasper Reviewed By: djasper Subscribers: djasper, cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D43906 llvm-svn: 327285
2018-03-12 23:42:40 +08:00
// 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 (^ObjCBlock)(void);
clang-format: Fix incorrect function type detection. Before: returnsFunction (&param1, &param2)(param); After: returnsFunction(&param1, &param2)(param); llvm-svn: 272538
2016-06-13 15:49:35 +08:00
bool MightBeFunctionType = !Contexts[Contexts.size() - 2].IsExpression;
[clang-format] Improve detection of Objective-C block types Summary: Previously, clang-format would detect the following as an Objective-C block type: FOO(^); when it actually must be a C or C++ macro dealing with an XOR statement or an XOR operator overload. According to the Clang Block Language Spec: https://clang.llvm.org/docs/BlockLanguageSpec.html block types are of the form: int (^)(char, float) and block variables of block type are of the form: void (^blockReturningVoidWithVoidArgument)(void); int (^blockReturningIntWithIntAndCharArguments)(int, char); void (^arrayOfTenBlocksReturningVoidWithIntArgument[10])(int); This tightens up the detection so we don't unnecessarily detect C macros which pass in the XOR operator. Depends On D43904 Test Plan: New tests added. Ran tests with: make -j12 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: krasimir, jolesiak, djasper Reviewed By: djasper Subscribers: djasper, cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D43906 llvm-svn: 327285
2018-03-12 23:42:40 +08:00
bool ProbablyFunctionType =
CurrentToken->isOneOf(tok::star, tok::amp, tok::caret);
Add experimental flag for adaptive parameter bin-packing. This is not activated for any style, might change or go away completely. For those that want to play around with it, set ExperimentalAutoDetectBinPacking to true. clang-format will then: Look at whether function calls/declarations/definitions are currently formatted with one parameter per line (on a case-by-case basis). If so, clang-format will avoid bin-packing the parameters. If all parameters are on one line (thus that line is "inconclusive"), clang-format will make the choice dependent on whether there are other bin-packed calls/declarations in the same file. The reason for this change is that bin-packing in some situations can be really bad and an author might opt to put one parameter on each line. If the author does that, he might want clang-format not to mess with that. If the author is unhappy with the one-per-line formatting, clang-format can easily be convinced to bin-pack by putting any two parameters on the same line. llvm-svn: 186003
2013-07-10 22:02:49 +08:00
bool HasMultipleLines = false;
bool HasMultipleParametersOnALine = false;
clang-format: Determine "in" as a keyword in ObjC for loops more precisely Before: for (int i = 0; i < in [a]; ++i) .. After: for (int i = 0; i < in[a]; ++i) .. Also do some related cleanups. llvm-svn: 234980
2015-04-15 15:26:18 +08:00
bool MightBeObjCForRangeLoop =
Left->Previous && Left->Previous->is(tok::kw_for);
[clang-format] Improve detection of ObjC for-in statements Summary: Previously, clang-format would detect the following as an Objective-C for-in statement: for (int x = in.value(); ...) {} because the logic only decided a for-loop was definitely *not* an Objective-C for-in loop after it saw a semicolon or a colon. To fix this, I delayed the decision of whether this was a for-in statement until after we found the matching right-paren, at which point we know if we've seen a semicolon or not. Test Plan: New tests added. Ran tests with: make -j12 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: krasimir, jolesiak Reviewed By: jolesiak Subscribers: djasper, cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D43904 llvm-svn: 326815
2018-03-07 01:21:42 +08:00
FormatToken *PossibleObjCForInToken = nullptr;
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
while (CurrentToken) {
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
// 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.
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
if (LookForDecls && CurrentToken->Next) {
Fixed typo: NoneComment -> NonComment, no other changes. llvm-svn: 185640
2013-07-04 22:47:51 +08:00
FormatToken *Prev = CurrentToken->getPreviousNonComment();
Fixed calculation of penalty when breaking tokens. Summary: Introduced two new style parameters: PenaltyBreakComment and PenaltyBreakString. Add penalty for each character of a breakable token beyond the column limit (this relates mainly to comments, as they are broken only on whitespace). Tuned PenaltyBreakComment to prefer comment breaking over breaking inside most binary expressions. Fixed a bug that prevented *, & and && from being considered TT_BinaryOperator in the presense of adjacent comments. Reviewers: klimek, djasper Reviewed By: klimek CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D933 llvm-svn: 183530
2013-06-08 00:02:52 +08:00
if (Prev) {
Fixed typo: NoneComment -> NonComment, no other changes. llvm-svn: 185640
2013-07-04 22:47:51 +08:00
FormatToken *PrevPrev = Prev->getPreviousNonComment();
Fixed calculation of penalty when breaking tokens. Summary: Introduced two new style parameters: PenaltyBreakComment and PenaltyBreakString. Add penalty for each character of a breakable token beyond the column limit (this relates mainly to comments, as they are broken only on whitespace). Tuned PenaltyBreakComment to prefer comment breaking over breaking inside most binary expressions. Fixed a bug that prevented *, & and && from being considered TT_BinaryOperator in the presense of adjacent comments. Reviewers: klimek, djasper Reviewed By: klimek CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D933 llvm-svn: 183530
2013-06-08 00:02:52 +08:00
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->Type = TT_BinaryOperator;
LookForDecls = false;
}
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
}
}
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (CurrentToken->Previous->is(TT_PointerOrReference) &&
clang-format: Correctly format alias declarations. Before: template <class CallbackClass> using MyCallback = void(CallbackClass::*)(SomeObject * Data);"); After: template <class CallbackClass> using MyCallback = void (CallbackClass::*)(SomeObject *Data);"); Also fix three wrong indentations. llvm-svn: 188172
2013-08-12 20:16:34 +08:00
CurrentToken->Previous->Previous->isOneOf(tok::l_paren,
tok::coloncolon))
clang-format: Fix incorrect function type detection. Before: returnsFunction (&param1, &param2)(param); After: returnsFunction(&param1, &param2)(param); llvm-svn: 272538
2016-06-13 15:49:35 +08:00
ProbablyFunctionType = true;
if (CurrentToken->is(tok::comma))
MightBeFunctionType = false;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (CurrentToken->Previous->is(TT_BinaryOperator))
clang-format: Improve expression heuristics. Upon encountering a binary operator inside parentheses, assume that the parentheses contain an expression. Before: MACRO('0' <= c&& c <= '9'); After: MACRO('0' <= c && c <= '9'); llvm-svn: 212040
2014-06-30 21:44:47 +08:00
Contexts.back().IsExpression = true;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
if (CurrentToken->is(tok::r_paren)) {
clang-format: Fix incorrect function type detection. Before: returnsFunction (&param1, &param2)(param); After: returnsFunction(&param1, &param2)(param); llvm-svn: 272538
2016-06-13 15:49:35 +08:00
if (MightBeFunctionType && ProbablyFunctionType && CurrentToken->Next &&
clang-format: Improve detection of function types. This fixes an incorrect detection that led to a formatting error. Before: some_var = function (*some_pointer_var)[0]; After: some_var = function(*some_pointer_var)[0]; llvm-svn: 186402
2013-07-16 19:37:21 +08:00
(CurrentToken->Next->is(tok::l_paren) ||
clang-format: Fix incorrect function type detection. Before: returnsFunction (&param1, &param2)(param); After: returnsFunction(&param1, &param2)(param); llvm-svn: 272538
2016-06-13 15:49:35 +08:00
(CurrentToken->Next->is(tok::l_square) && Line.MustBeDeclaration)))
[clang-format] Improve detection of Objective-C block types Summary: Previously, clang-format would detect the following as an Objective-C block type: FOO(^); when it actually must be a C or C++ macro dealing with an XOR statement or an XOR operator overload. According to the Clang Block Language Spec: https://clang.llvm.org/docs/BlockLanguageSpec.html block types are of the form: int (^)(char, float) and block variables of block type are of the form: void (^blockReturningVoidWithVoidArgument)(void); int (^blockReturningIntWithIntAndCharArguments)(int, char); void (^arrayOfTenBlocksReturningVoidWithIntArgument[10])(int); This tightens up the detection so we don't unnecessarily detect C macros which pass in the XOR operator. Depends On D43904 Test Plan: New tests added. Ran tests with: make -j12 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: krasimir, jolesiak, djasper Reviewed By: djasper Subscribers: djasper, cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D43906 llvm-svn: 327285
2018-03-12 23:42:40 +08:00
Left->Type = Left->Next->is(tok::caret) ? TT_ObjCBlockLParen
: TT_FunctionTypeLParen;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
Left->MatchingParen = CurrentToken;
CurrentToken->MatchingParen = Left;
clang-format: Support weird lambda macros. Before: MACRO((AA & a) { return 1; }); After: MACRO((AA &a) { return 1; }); llvm-svn: 257062
2016-01-07 22:36:11 +08:00
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 = MARCO((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->Type = TT_PointerOrReference;
}
}
Initial support for formatting ObjC method declarations/calls. We can now format stuff like: - (void)doSomethingWith:(GTMFoo *)theFoo rect:(NSRect)theRect interval:(float)theInterval { [myObject doFooWith:arg1 // name:arg2 error:arg3]; } This seems to fix everything mentioned in llvm.org/PR14939. llvm-svn: 174364
2013-02-05 18:07:47 +08:00
if (StartsObjCMethodExpr) {
Handle nested ObjC calls. Properly handle annotation contexts while calculating extra information for each token. This enable nested ObjC calls and thus solves (most of) llvm.org/PR15164. E.g., we can now format: [contentsContainer replaceSubview:[subviews objectAtIndex:0] with:contentsNativeView]; Also fix a problem with the formatting of types in casts as this was trivial now. llvm-svn: 174498
2013-02-06 18:05:46 +08:00
CurrentToken->Type = TT_ObjCMethodExpr;
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
if (Contexts.back().FirstObjCSelectorName) {
Handle nested ObjC calls. Properly handle annotation contexts while calculating extra information for each token. This enable nested ObjC calls and thus solves (most of) llvm.org/PR15164. E.g., we can now format: [contentsContainer replaceSubview:[subviews objectAtIndex:0] with:contentsNativeView]; Also fix a problem with the formatting of types in casts as this was trivial now. llvm-svn: 174498
2013-02-06 18:05:46 +08:00
Contexts.back().FirstObjCSelectorName->LongestObjCSelectorName =
Contexts.back().LongestObjCSelectorName;
Initial support for formatting ObjC method declarations/calls. We can now format stuff like: - (void)doSomethingWith:(GTMFoo *)theFoo rect:(NSRect)theRect interval:(float)theInterval { [myObject doFooWith:arg1 // name:arg2 error:arg3]; } This seems to fix everything mentioned in llvm.org/PR14939. llvm-svn: 174364
2013-02-05 18:07:47 +08:00
}
}
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Left->is(TT_AttributeParen))
clang-format: Understand __attribute__s preceding parameter lists. Before: ReturnType __attribute__((unused)) function(int i); After: ReturnType __attribute__((unused)) function(int i); This fixes llvm.org/PR18632. llvm-svn: 200337
2014-01-29 04:13:43 +08:00
CurrentToken->Type = TT_AttributeParen;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Left->Previous && Left->Previous->is(TT_JavaAnnotation))
clang-format: [Java] Support annotations with parameters. Before: @SuppressWarnings (value = "unchecked") public void doSomething() { .. } After: @SuppressWarnings(value = "unchecked") public void doSomething() { .. } llvm-svn: 220279
2014-10-21 17:25:39 +08:00
CurrentToken->Type = TT_JavaAnnotation;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Left->Previous && Left->Previous->is(TT_LeadingJavaAnnotation))
clang-format: [Java] Improve line breaks around annotations. Before: @SomeAnnotation("With some really looooooooooooooong text") private static final long something = 0L; void SomeFunction(@Nullable String something) {} After: @SomeAnnotation("With some really looooooooooooooong text") private static final long something = 0L; void SomeFunction(@Nullable String something) {} llvm-svn: 220984
2014-11-01 02:23:49 +08:00
CurrentToken->Type = TT_LeadingJavaAnnotation;
clang-format: Understand __attribute__s preceding parameter lists. Before: ReturnType __attribute__((unused)) function(int i); After: ReturnType __attribute__((unused)) function(int i); This fixes llvm.org/PR18632. llvm-svn: 200337
2014-01-29 04:13:43 +08:00
Add experimental flag for adaptive parameter bin-packing. This is not activated for any style, might change or go away completely. For those that want to play around with it, set ExperimentalAutoDetectBinPacking to true. clang-format will then: Look at whether function calls/declarations/definitions are currently formatted with one parameter per line (on a case-by-case basis). If so, clang-format will avoid bin-packing the parameters. If all parameters are on one line (thus that line is "inconclusive"), clang-format will make the choice dependent on whether there are other bin-packed calls/declarations in the same file. The reason for this change is that bin-packing in some situations can be really bad and an author might opt to put one parameter on each line. If the author does that, he might want clang-format not to mess with that. If the author is unhappy with the one-per-line formatting, clang-format can easily be convinced to bin-pack by putting any two parameters on the same line. llvm-svn: 186003
2013-07-10 22:02:49 +08:00
if (!HasMultipleLines)
Left->PackingKind = PPK_Inconclusive;
else if (HasMultipleParametersOnALine)
Left->PackingKind = PPK_BinPacked;
else
Left->PackingKind = PPK_OnePerLine;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
next();
return true;
}
Added AnnotatedToken::isOneOf + a few other refactorings Summary: <subj> Reviewers: djasper Reviewed By: djasper CC: cfe-commits, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D536 llvm-svn: 176951
2013-03-13 22:41:29 +08:00
if (CurrentToken->isOneOf(tok::r_square, tok::r_brace))
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return false;
clang-format: Determine "in" as a keyword in ObjC for loops more precisely Before: for (int i = 0; i < in [a]; ++i) .. After: for (int i = 0; i < in[a]; ++i) .. Also do some related cleanups. llvm-svn: 234980
2015-04-15 15:26:18 +08:00
if (CurrentToken->is(tok::l_brace))
clang-format: Fix ObjC block as first call parameter formatting. Before: foo (^{ bar(); }); After: foo(^{ bar(); }); llvm-svn: 199573
2014-01-19 15:46:32 +08:00
Left->Type = TT_Unknown; // Not TT_ObjCBlockLParen
Add experimental flag for adaptive parameter bin-packing. This is not activated for any style, might change or go away completely. For those that want to play around with it, set ExperimentalAutoDetectBinPacking to true. clang-format will then: Look at whether function calls/declarations/definitions are currently formatted with one parameter per line (on a case-by-case basis). If so, clang-format will avoid bin-packing the parameters. If all parameters are on one line (thus that line is "inconclusive"), clang-format will make the choice dependent on whether there are other bin-packed calls/declarations in the same file. The reason for this change is that bin-packing in some situations can be really bad and an author might opt to put one parameter on each line. If the author does that, he might want clang-format not to mess with that. If the author is unhappy with the one-per-line formatting, clang-format can easily be convinced to bin-pack by putting any two parameters on the same line. llvm-svn: 186003
2013-07-10 22:02:49 +08:00
if (CurrentToken->is(tok::comma) && CurrentToken->Next &&
!CurrentToken->Next->HasUnescapedNewline &&
!CurrentToken->Next->isTrailingComment())
HasMultipleParametersOnALine = true;
clang-format: Fix incorrect pointer detection. Before: void f() { f(float{1}, a *a); } After: void f() { f(float{1}, a * a); } llvm-svn: 285673
2016-11-01 14:23:14 +08:00
if ((CurrentToken->Previous->isOneOf(tok::kw_const, tok::kw_auto) ||
CurrentToken->Previous->isSimpleTypeSpecifier()) &&
!CurrentToken->is(tok::l_brace))
clang-format: Detect weird macro lambda usage. Before: void f() { MACRO((const AA & a) { return 1; }); } After: void f() { MACRO((const AA &a) { return 1; }); } llvm-svn: 203551
2014-03-11 17:29:46 +08:00
Contexts.back().IsExpression = false;
[clang-format] Improve detection of ObjC for-in statements Summary: Previously, clang-format would detect the following as an Objective-C for-in statement: for (int x = in.value(); ...) {} because the logic only decided a for-loop was definitely *not* an Objective-C for-in loop after it saw a semicolon or a colon. To fix this, I delayed the decision of whether this was a for-in statement until after we found the matching right-paren, at which point we know if we've seen a semicolon or not. Test Plan: New tests added. Ran tests with: make -j12 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: krasimir, jolesiak Reviewed By: jolesiak Subscribers: djasper, cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D43904 llvm-svn: 326815
2018-03-07 01:21:42 +08:00
if (CurrentToken->isOneOf(tok::semi, tok::colon)) {
clang-format: Determine "in" as a keyword in ObjC for loops more precisely Before: for (int i = 0; i < in [a]; ++i) .. After: for (int i = 0; i < in[a]; ++i) .. Also do some related cleanups. llvm-svn: 234980
2015-04-15 15:26:18 +08:00
MightBeObjCForRangeLoop = false;
[clang-format] Improve detection of ObjC for-in statements Summary: Previously, clang-format would detect the following as an Objective-C for-in statement: for (int x = in.value(); ...) {} because the logic only decided a for-loop was definitely *not* an Objective-C for-in loop after it saw a semicolon or a colon. To fix this, I delayed the decision of whether this was a for-in statement until after we found the matching right-paren, at which point we know if we've seen a semicolon or not. Test Plan: New tests added. Ran tests with: make -j12 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: krasimir, jolesiak Reviewed By: jolesiak Subscribers: djasper, cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D43904 llvm-svn: 326815
2018-03-07 01:21:42 +08:00
if (PossibleObjCForInToken) {
PossibleObjCForInToken->Type = TT_Unknown;
PossibleObjCForInToken = nullptr;
}
}
if (MightBeObjCForRangeLoop && CurrentToken->is(Keywords.kw_in)) {
PossibleObjCForInToken = CurrentToken;
PossibleObjCForInToken->Type = TT_ObjCForIn;
}
clang-format: Fix incorrect */& classification. Before: void f() { f(new a(), c *d); } After: void f() { f(new a(), c * d); } llvm-svn: 237249
2015-05-13 20:54:30 +08:00
// 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;
clang-format: Determine "in" as a keyword in ObjC for loops more precisely Before: for (int i = 0; i < in [a]; ++i) .. After: for (int i = 0; i < in[a]; ++i) .. Also do some related cleanups. llvm-svn: 234980
2015-04-15 15:26:18 +08:00
clang-format: Refactor indentation behavior for multiple nested blocks. This fixes a few oddities when formatting multiple nested JavaScript blocks, e.g.: Before: promise.then( function success() { doFoo(); doBar(); }, [], function error() { doFoo(); doBaz(); }); promise.then([], function success() { doFoo(); doBar(); }, function error() { doFoo(); doBaz(); }); After: promise.then( function success() { doFoo(); doBar(); }, [], function error() { doFoo(); doBaz(); }); promise.then([], function success() { doFoo(); doBar(); }, function error() { doFoo(); doBaz(); }); llvm-svn: 210097
2014-06-03 20:02:45 +08:00
FormatToken *Tok = CurrentToken;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
if (!consumeToken())
return false;
clang-format: Refactor indentation behavior for multiple nested blocks. This fixes a few oddities when formatting multiple nested JavaScript blocks, e.g.: Before: promise.then( function success() { doFoo(); doBar(); }, [], function error() { doFoo(); doBaz(); }); promise.then([], function success() { doFoo(); doBar(); }, function error() { doFoo(); doBaz(); }); After: promise.then( function success() { doFoo(); doBar(); }, [], function error() { doFoo(); doBaz(); }); promise.then([], function success() { doFoo(); doBar(); }, function error() { doFoo(); doBaz(); }); llvm-svn: 210097
2014-06-03 20:02:45 +08:00
updateParameterCount(Left, Tok);
Add experimental flag for adaptive parameter bin-packing. This is not activated for any style, might change or go away completely. For those that want to play around with it, set ExperimentalAutoDetectBinPacking to true. clang-format will then: Look at whether function calls/declarations/definitions are currently formatted with one parameter per line (on a case-by-case basis). If so, clang-format will avoid bin-packing the parameters. If all parameters are on one line (thus that line is "inconclusive"), clang-format will make the choice dependent on whether there are other bin-packed calls/declarations in the same file. The reason for this change is that bin-packing in some situations can be really bad and an author might opt to put one parameter on each line. If the author does that, he might want clang-format not to mess with that. If the author is unhappy with the one-per-line formatting, clang-format can easily be convinced to bin-pack by putting any two parameters on the same line. llvm-svn: 186003
2013-07-10 22:02:49 +08:00
if (CurrentToken && CurrentToken->HasUnescapedNewline)
HasMultipleLines = true;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
}
return false;
}
[clang-format] Don't detect C++11 attribute specifiers as ObjC Summary: Previously, clang-format would detect C++11 and C++17 attribute specifiers like the following as Objective-C method invocations: [[noreturn]]; [[clang::fallthrough]]; [[noreturn, deprecated("so sorry")]]; [[using gsl: suppress("type")]]; To fix this, I ported part of the logic from tools/clang/lib/Parse/ParseTentative.cpp into TokenAnnotator.cpp so we can explicitly parse and identify C++11 attribute specifiers. This allows the guessLanguage() and getStyle() APIs to correctly guess files containing the C++11 attribute specifiers as C++, not Objective-C. Test Plan: New tests added. Ran tests with: make -j12 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: krasimir, jolesiak, djasper Reviewed By: djasper Subscribers: aaron.ballman, cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D43902 llvm-svn: 327284
2018-03-12 23:42:38 +08:00
bool isCpp11AttributeSpecifier(const FormatToken &Tok) {
if (!Style.isCpp() || !Tok.startsSequence(tok::l_square, tok::l_square))
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))
return false;
if (AttrTok->is(tok::ellipsis))
return true;
AttrTok = AttrTok->Next;
}
return AttrTok && AttrTok->startsSequence(tok::r_square, tok::r_square);
}
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
bool parseSquare() {
if (!CurrentToken)
return false;
Fix a problem in ExpressionParser leading to trailing comments affecting indentation of an expression after a line break. Summary: E.g. the second line in return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + b; // is indented 4 characters more than in return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + b; Reviewers: klimek Reviewed By: klimek CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D984 llvm-svn: 184078
2013-06-17 21:19:53 +08:00
// A '[' could be an index subscript (after an identifier or after
Formatter: Detect ObjC array literals. Use this to add a space after "@[" and before "]" for now. Later, I want to use this to format multi-line array literals nicer, too. llvm-svn: 174822
2013-02-10 10:08:05 +08:00
// ')' or ']'), it could be the start of an Objective-C method
[clang-format] Don't detect C++11 attribute specifiers as ObjC Summary: Previously, clang-format would detect C++11 and C++17 attribute specifiers like the following as Objective-C method invocations: [[noreturn]]; [[clang::fallthrough]]; [[noreturn, deprecated("so sorry")]]; [[using gsl: suppress("type")]]; To fix this, I ported part of the logic from tools/clang/lib/Parse/ParseTentative.cpp into TokenAnnotator.cpp so we can explicitly parse and identify C++11 attribute specifiers. This allows the guessLanguage() and getStyle() APIs to correctly guess files containing the C++11 attribute specifiers as C++, not Objective-C. Test Plan: New tests added. Ran tests with: make -j12 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: krasimir, jolesiak, djasper Reviewed By: djasper Subscribers: aaron.ballman, cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D43902 llvm-svn: 327284
2018-03-12 23:42:38 +08:00
// expression, it could the start of an Objective-C array literal,
// or it could be a C++ attribute specifier [[foo::bar]].
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
FormatToken *Left = CurrentToken->Previous;
clang-format: Force aligning different brackets relative to each other. Before: void SomeFunction(vector< // break int> v); After: void SomeFunction(vector< // break int> v); llvm-svn: 236412
2015-05-04 15:39:00 +08:00
Left->ParentBracket = Contexts.back().ContextKind;
Fixed typo: NoneComment -> NonComment, no other changes. llvm-svn: 185640
2013-07-04 22:47:51 +08:00
FormatToken *Parent = Left->getPreviousNonComment();
[clang-format] Fix PR30527: Regression when clang-format insert spaces in [] when in template Actual regression was introduced in r272668. This revision fixes JS script, but also regress Cpp case. It manifests with spaces added when template is followed with array. Bug 30527 mentions case of array as a nested template type (foo<bar<baz>[]>). Fix is to detect such case and to prevent treating it as array initialization, but as a subscript case. However, before r272668, this case was treated simple because we were detecting it as a StartsObjCMethodExpr. Same was true for other similar case - array of templates (foo<int>[]). This patch tries to address two problems: 1) fixing regression 2) making sure both cases (array as a nested type, array of templates) which were entering StartsObjCMethodExpr branch are handled now appropriately. https://reviews.llvm.org/D26163 Patch from Branko Kokanovic <branko@kokanovic.org>! llvm-svn: 286507
2016-11-11 05:49:25 +08:00
// 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 =
clang-format clang-format. llvm-svn: 313744
2017-09-20 17:51:03 +08:00
Style.isCpp() && Parent && Parent->is(TT_TemplateCloser) &&
[clang-format] Fix PR30527: Regression when clang-format insert spaces in [] when in template Actual regression was introduced in r272668. This revision fixes JS script, but also regress Cpp case. It manifests with spaces added when template is followed with array. Bug 30527 mentions case of array as a nested template type (foo<bar<baz>[]>). Fix is to detect such case and to prevent treating it as array initialization, but as a subscript case. However, before r272668, this case was treated simple because we were detecting it as a StartsObjCMethodExpr. Same was true for other similar case - array of templates (foo<int>[]). This patch tries to address two problems: 1) fixing regression 2) making sure both cases (array as a nested type, array of templates) which were entering StartsObjCMethodExpr branch are handled now appropriately. https://reviews.llvm.org/D26163 Patch from Branko Kokanovic <branko@kokanovic.org>! llvm-svn: 286507
2016-11-11 05:49:25 +08:00
(Contexts.back().CanBeExpression || Contexts.back().IsExpression ||
Contexts.back().InTemplateArgument);
[clang-format] Don't detect C++11 attribute specifiers as ObjC Summary: Previously, clang-format would detect C++11 and C++17 attribute specifiers like the following as Objective-C method invocations: [[noreturn]]; [[clang::fallthrough]]; [[noreturn, deprecated("so sorry")]]; [[using gsl: suppress("type")]]; To fix this, I ported part of the logic from tools/clang/lib/Parse/ParseTentative.cpp into TokenAnnotator.cpp so we can explicitly parse and identify C++11 attribute specifiers. This allows the guessLanguage() and getStyle() APIs to correctly guess files containing the C++11 attribute specifiers as C++, not Objective-C. Test Plan: New tests added. Ran tests with: make -j12 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: krasimir, jolesiak, djasper Reviewed By: djasper Subscribers: aaron.ballman, cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D43902 llvm-svn: 327284
2018-03-12 23:42:38 +08:00
bool IsCpp11AttributeSpecifier = isCpp11AttributeSpecifier(*Left) ||
Contexts.back().InCpp11AttributeSpecifier;
clang-format: Support ObjC selectors with unnamed parameters. This fixes llvm.org/PR28063. llvm-svn: 286715
2016-11-12 15:38:22 +08:00
bool StartsObjCMethodExpr =
[clang-format] Don't detect C++11 attribute specifiers as ObjC Summary: Previously, clang-format would detect C++11 and C++17 attribute specifiers like the following as Objective-C method invocations: [[noreturn]]; [[clang::fallthrough]]; [[noreturn, deprecated("so sorry")]]; [[using gsl: suppress("type")]]; To fix this, I ported part of the logic from tools/clang/lib/Parse/ParseTentative.cpp into TokenAnnotator.cpp so we can explicitly parse and identify C++11 attribute specifiers. This allows the guessLanguage() and getStyle() APIs to correctly guess files containing the C++11 attribute specifiers as C++, not Objective-C. Test Plan: New tests added. Ran tests with: make -j12 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: krasimir, jolesiak, djasper Reviewed By: djasper Subscribers: aaron.ballman, cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D43902 llvm-svn: 327284
2018-03-12 23:42:38 +08:00
!CppArrayTemplates && Style.isCpp() && !IsCpp11AttributeSpecifier &&
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
Contexts.back().CanBeExpression && Left->isNot(TT_LambdaLSquare) &&
[clang-format/ObjC] Do not detect "[]" as ObjC method expression Summary: The following C++ code was being detected by `guessLanguage()` as Objective-C: #define FOO(...) auto bar = [] __VA_ARGS__; This was because `[] __VA_ARGS__` is not currently detected as a C++ lambda expression (it has no parens or braces), so `TokenAnnotator::parseSquare()` incorrectly treats the opening square as an ObjC method expression. We have two options to fix this: 1. Parse `[] __VA_ARGS__` explicitly as a C++ lambda 2. Make it so `[]` is never parsed as an Objective-C method expression This diff implements option 2, which causes the `[` to be parsed as `TT_ArraySubscriptLSquare` instead of `TT_ObjCMethodExpr`. Note that when I fixed this, it caused one change in formatting behavior, where the following was implicitly relying on the `[` being parsed as `TT_ObjCMethodExpr`: A<int * []> a; becomes: A<int *[]> a; with `Style.PointerAlignment = Middle`. I don't really know what the desired format is for this syntax; the test was added by Janusz Sobczak and integrated by @djasper in https://github.com/llvm-mirror/clang/commit/b511fe9818829d7ece0cc0b2ce1fbe04a1f0739a . I went ahead and changed the test for now. Test Plan: New tests added. Ran tests with: % make -j12 FormatTests && ./tools/clang/unittests/Format/FormatTests Fixes: https://bugs.llvm.org/show_bug.cgi?id=36248 Reviewers: djasper, jolesiak Reviewed By: djasper Subscribers: klimek, cfe-commits, djasper Differential Revision: https://reviews.llvm.org/D45169 llvm-svn: 329070
2018-04-03 22:07:11 +08:00
!CurrentToken->isOneOf(tok::l_brace, tok::r_square) &&
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
(!Parent ||
Parent->isOneOf(tok::colon, tok::l_square, tok::l_paren,
tok::kw_return, tok::kw_throw) ||
Parent->isUnaryOperator() ||
[clang-format] Ensure ObjC selectors with 0 args are annotated correctly Summary: Previously, clang-format would incorrectly annotate 0-argument Objective-C selector names as TT_TrailingAnnotation: ``` % echo "-(void)foo;" > /tmp/test.m % ./bin/clang-format -debug /tmp/test.m Language: Objective-C ---- Line(0, FSC=0): minus[T=68, OC=0] l_paren[T=68, OC=1] void[T=68, OC=2] r_paren[T=68, OC=6] identifier[T=68, OC=7] semi[T=68, OC=10] Line(0, FSC=0): eof[T=68, OC=0] Run 0... AnnotatedTokens(L=0): M=0 C=0 T=ObjCMethodSpecifier S=1 B=0 BK=0 P=0 Name=minus L=1 PPK=2 FakeLParens= FakeRParens=0 Text='-' M=0 C=1 T=Unknown S=1 B=0 BK=0 P=33 Name=l_paren L=3 PPK=2 FakeLParens= FakeRParens=0 Text='(' M=0 C=1 T=Unknown S=0 B=0 BK=0 P=140 Name=void L=7 PPK=2 FakeLParens= FakeRParens=0 Text='void' M=0 C=0 T=CastRParen S=0 B=0 BK=0 P=43 Name=r_paren L=8 PPK=2 FakeLParens= FakeRParens=0 Text=')' M=0 C=1 T=TrailingAnnotation S=0 B=0 BK=0 P=120 Name=identifier L=11 PPK=2 FakeLParens= FakeRParens=0 Text='foo' M=0 C=0 T=Unknown S=0 B=0 BK=0 P=23 Name=semi L=12 PPK=2 FakeLParens= FakeRParens=0 Text=';' ``` This caused us to incorrectly indent 0-argument wrapped selectors when Style.IndentWrappedFunctionNames was false, as we thought the 0-argument ObjC selector name was actually a trailing annotation (which is always indented). This diff fixes the issue and adds tests. Test Plan: New tests added. Confirmed tests failed before diff. After diff, tests passed. Ran tests with: % make -j12 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: djasper, jolesiak Reviewed By: djasper, jolesiak Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D44996 llvm-svn: 329297
2018-04-05 23:26:23 +08:00
// FIXME(bug 36976): ObjC return types shouldn't use TT_CastRParen.
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
Parent->isOneOf(TT_ObjCForIn, TT_CastRParen) ||
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
getBinOpPrecedence(Parent->Tok.getKind(), true, true) > prec::Unknown);
clang-format: Fix ObjC method exprs with variadic parameters. Before: _versionLabel.text = [ NSString stringWithFormat:NSLocalizedString(@"version: %@", @"Label"), [NSBundle mainBundle].infoDictionary[@"CFBundleShortVersionString"] ]; After: _versionLabel.text = [NSString stringWithFormat:NSLocalizedString(@"version: %@", @"Label"), [NSBundle mainBundle].infoDictionary[@"CFBundleShortVersionString"]]; This fixed llvm.org/PR17695. llvm-svn: 193475
2013-10-27 01:00:22 +08:00
bool ColonFound = false;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
clang-format: Lower binding strengths created by the [] created by ObjC method expressions and array literals. They should not bind stronger than regular parentheses or the braces of braced lists. Specific test case in JavaScript: Before: var aaaaa: List< SomeThing> = [new SomeThingAAAAAAAAAAAA(), new SomeThingBBBBBBBBB()]; After: var aaaaa: List<SomeThing> = [ new SomeThingAAAAAAAAAAAA(), new SomeThingBBBBBBBBB() ]; llvm-svn: 238400
2015-05-28 15:21:50 +08:00
unsigned BindingIncrease = 1;
[clang-format] Adjust space around &/&& of structured bindings Keep space before or after the &/&& tokens, but not both. For example, auto [x,y] = a; auto &[xr, yr] = a; // LLVM style auto& [xr, yr] = a; // google style Differential Revision:https://reviews.llvm.org/D35743 llvm-svn: 314264
2017-09-27 08:58:45 +08:00
if (Left->isCppStructuredBinding(Style)) {
Left->Type = TT_StructuredBindingLSquare;
} else if (Left->is(TT_Unknown)) {
if (StartsObjCMethodExpr) {
clang-format: Lower binding strengths created by the [] created by ObjC method expressions and array literals. They should not bind stronger than regular parentheses or the braces of braced lists. Specific test case in JavaScript: Before: var aaaaa: List< SomeThing> = [new SomeThingAAAAAAAAAAAA(), new SomeThingBBBBBBBBB()]; After: var aaaaa: List<SomeThing> = [ new SomeThingAAAAAAAAAAAA(), new SomeThingBBBBBBBBB() ]; llvm-svn: 238400
2015-05-28 15:21:50 +08:00
Left->Type = TT_ObjCMethodExpr;
[clang-format] Don't detect C++11 attribute specifiers as ObjC Summary: Previously, clang-format would detect C++11 and C++17 attribute specifiers like the following as Objective-C method invocations: [[noreturn]]; [[clang::fallthrough]]; [[noreturn, deprecated("so sorry")]]; [[using gsl: suppress("type")]]; To fix this, I ported part of the logic from tools/clang/lib/Parse/ParseTentative.cpp into TokenAnnotator.cpp so we can explicitly parse and identify C++11 attribute specifiers. This allows the guessLanguage() and getStyle() APIs to correctly guess files containing the C++11 attribute specifiers as C++, not Objective-C. Test Plan: New tests added. Ran tests with: make -j12 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: krasimir, jolesiak, djasper Reviewed By: djasper Subscribers: aaron.ballman, cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D43902 llvm-svn: 327284
2018-03-12 23:42:38 +08:00
} else if (IsCpp11AttributeSpecifier) {
Left->Type = TT_AttributeSquare;
clang-format: [JS] Support ES6 computed property names. Before: var x = { [a]: 1, b: 2 }; After: var x = { [a]: 1, b: 2 }; llvm-svn: 238544
2015-05-29 14:19:49 +08:00
} else if (Style.Language == FormatStyle::LK_JavaScript && Parent &&
clang-format: [JS] Fix another regression when detecting array literals. llvm-svn: 238835
2015-06-02 22:20:08 +08:00
Contexts.back().ContextKind == tok::l_brace &&
clang-format: [JS] Support ES6 computed property names. Before: var x = { [a]: 1, b: 2 }; After: var x = { [a]: 1, b: 2 }; llvm-svn: 238544
2015-05-29 14:19:49 +08:00
Parent->isOneOf(tok::l_brace, tok::comma)) {
Left->Type = TT_JsComputedPropertyName;
clang-format: Fix C99 designated initializers corner cases Summary: This fixes the missing space before the designated initializer when `Cpp11BracedListStyle=false` : const struct A a = { .a = 1, .b = 2 }; ^ Also, wrapping between opening brace and designated array initializers used to have an excessive penalty (like breaking between an expression and the subscript operator), leading to unexpected wrapping: const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {[1] = aaaaaaaaaaaaaaaaaaaaaaaaaaa, [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbb}; instead of: const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = { [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaa, [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbb}; Finally, designated array initializers are not binpacked, just like designated member initializers. Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, krasimir, klimek Differential Revision: https://reviews.llvm.org/D33491 llvm-svn: 305696
2017-06-19 22:41:21 +08:00
} else if (Style.isCpp() && Contexts.back().ContextKind == tok::l_brace &&
Parent && Parent->isOneOf(tok::l_brace, tok::comma)) {
Left->Type = TT_DesignatedInitializerLSquare;
clang-format: [JS/TS] Improve detection for array subscripts in types. Before: var someValue = (v as aaaaaaaaaaaaaaaaaaaa<T>[ ]).someFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa); After: var someValue = (v as aaaaaaaaaaaaaaaaaaaa<T>[]) .someFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa); llvm-svn: 295658
2017-02-20 20:43:41 +08:00
} else if (CurrentToken->is(tok::r_square) && Parent &&
Parent->is(TT_TemplateCloser)) {
Left->Type = TT_ArraySubscriptLSquare;
clang-format: [Proto] Improve wrapping of message field attributes. Before: optional AAA aaa = 1 [foo = { key: "a" // }, bar = { key: "a" // }]; After: optional AAA aaa = 1 [ foo = { key: "a" // }, bar = { key: "a" // } ]; llvm-svn: 256736
2016-01-04 15:27:33 +08:00
} else if (Style.Language == FormatStyle::LK_Proto ||
[clang-format] Support text proto extensions Summary: This adds support for text proto extensions, like: ``` msg { [type.type/ext] { key: value } } ``` Reviewers: djasper Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D43180 llvm-svn: 324995
2018-02-13 18:20:39 +08:00
Style.Language == FormatStyle::LK_TextProto) {
// Square braces in LK_Proto can either be message field attributes:
//
// optional Aaa aaa = 1 [
// (aaa) = aaa
// ];
//
[clang-format] Fixup a case of text proto message attributes Summary: This patch fixes a case where a proto message attribute is wrongly identified as an text proto extension. Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D43465 llvm-svn: 325509
2018-02-19 23:31:25 +08:00
// extensions 123 [
// (aaa) = aaa
// ];
//
[clang-format] Support text proto extensions Summary: This adds support for text proto extensions, like: ``` msg { [type.type/ext] { key: value } } ``` Reviewers: djasper Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D43180 llvm-svn: 324995
2018-02-13 18:20:39 +08:00
// or text proto extensions (in options):
//
// option (Aaa.options) = {
// [type.type/type] {
// key: value
// }
// }
//
[clang-format] Support repeated field lists in protos Summary: This patch adds support for list initialization of proto repeated fields: ``` keys: [1, 2, 3] ``` Reviewers: djasper Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D43298 llvm-svn: 325252
2018-02-15 23:30:22 +08:00
// 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.
[clang-format] Support text proto extensions Summary: This adds support for text proto extensions, like: ``` msg { [type.type/ext] { key: value } } ``` Reviewers: djasper Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D43180 llvm-svn: 324995
2018-02-13 18:20:39 +08:00
Left->Type = TT_ArrayInitializerLSquare;
if (!Left->endsSequence(tok::l_square, tok::numeric_constant,
[clang-format] Support repeated field lists in protos Summary: This patch adds support for list initialization of proto repeated fields: ``` keys: [1, 2, 3] ``` Reviewers: djasper Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D43298 llvm-svn: 325252
2018-02-15 23:30:22 +08:00
tok::equal) &&
[clang-format] Fixup a case of text proto message attributes Summary: This patch fixes a case where a proto message attribute is wrongly identified as an text proto extension. Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D43465 llvm-svn: 325509
2018-02-19 23:31:25 +08:00
!Left->endsSequence(tok::l_square, tok::numeric_constant,
tok::identifier) &&
[clang-format] Support repeated field lists in protos Summary: This patch adds support for list initialization of proto repeated fields: ``` keys: [1, 2, 3] ``` Reviewers: djasper Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D43298 llvm-svn: 325252
2018-02-15 23:30:22 +08:00
!Left->endsSequence(tok::l_square, tok::colon, TT_SelectorName)) {
[clang-format] Support text proto extensions Summary: This adds support for text proto extensions, like: ``` msg { [type.type/ext] { key: value } } ``` Reviewers: djasper Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D43180 llvm-svn: 324995
2018-02-13 18:20:39 +08:00
Left->Type = 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)) {
clang-format: Lower binding strengths created by the [] created by ObjC method expressions and array literals. They should not bind stronger than regular parentheses or the braces of braced lists. Specific test case in JavaScript: Before: var aaaaa: List< SomeThing> = [new SomeThingAAAAAAAAAAAA(), new SomeThingBBBBBBBBB()]; After: var aaaaa: List<SomeThing> = [ new SomeThingAAAAAAAAAAAA(), new SomeThingBBBBBBBBB() ]; llvm-svn: 238400
2015-05-28 15:21:50 +08:00
Left->Type = TT_ArrayInitializerLSquare;
} else {
BindingIncrease = 10;
Left->Type = TT_ArraySubscriptLSquare;
}
Handle nested ObjC calls. Properly handle annotation contexts while calculating extra information for each token. This enable nested ObjC calls and thus solves (most of) llvm.org/PR15164. E.g., we can now format: [contentsContainer replaceSubview:[subviews objectAtIndex:0] with:contentsNativeView]; Also fix a problem with the formatting of types in casts as this was trivial now. llvm-svn: 174498
2013-02-06 18:05:46 +08:00
}
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
clang-format: Lower binding strengths created by the [] created by ObjC method expressions and array literals. They should not bind stronger than regular parentheses or the braces of braced lists. Specific test case in JavaScript: Before: var aaaaa: List< SomeThing> = [new SomeThingAAAAAAAAAAAA(), new SomeThingBBBBBBBBB()]; After: var aaaaa: List<SomeThing> = [ new SomeThingAAAAAAAAAAAA(), new SomeThingBBBBBBBBB() ]; llvm-svn: 238400
2015-05-28 15:21:50 +08:00
ScopedContextCreator ContextCreator(*this, tok::l_square, BindingIncrease);
Contexts.back().IsExpression = true;
clang-format: [JS] fix union type spacing in object & array types. Summary: Previously, clang-format would insert whitespace in union types nested in object and array types, as it wouldn't recognize those as a type operator: const x: {foo: number | null}; const x: [number | null]; While this is correct for actual binary operators, clang-format should not insert whitespace into union and intersection types to mark those: const x: {foo: number|null}; const x: [number|null]; This change propagates that the context is not an expression by inspecting the preceding token and marking as non-expression if it was a type colon. Reviewers: djasper Subscribers: klimek Differential Revision: https://reviews.llvm.org/D36136 llvm-svn: 310367
2017-08-08 23:00:58 +08:00
if (Style.Language == FormatStyle::LK_JavaScript && Parent &&
Parent->is(TT_JsTypeColon))
Contexts.back().IsExpression = false;
clang-format: Lower binding strengths created by the [] created by ObjC method expressions and array literals. They should not bind stronger than regular parentheses or the braces of braced lists. Specific test case in JavaScript: Before: var aaaaa: List< SomeThing> = [new SomeThingAAAAAAAAAAAA(), new SomeThingBBBBBBBBB()]; After: var aaaaa: List<SomeThing> = [ new SomeThingAAAAAAAAAAAA(), new SomeThingBBBBBBBBB() ]; llvm-svn: 238400
2015-05-28 15:21:50 +08:00
Contexts.back().ColonIsObjCMethodExpr = StartsObjCMethodExpr;
[clang-format] Don't detect C++11 attribute specifiers as ObjC Summary: Previously, clang-format would detect C++11 and C++17 attribute specifiers like the following as Objective-C method invocations: [[noreturn]]; [[clang::fallthrough]]; [[noreturn, deprecated("so sorry")]]; [[using gsl: suppress("type")]]; To fix this, I ported part of the logic from tools/clang/lib/Parse/ParseTentative.cpp into TokenAnnotator.cpp so we can explicitly parse and identify C++11 attribute specifiers. This allows the guessLanguage() and getStyle() APIs to correctly guess files containing the C++11 attribute specifiers as C++, not Objective-C. Test Plan: New tests added. Ran tests with: make -j12 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: krasimir, jolesiak, djasper Reviewed By: djasper Subscribers: aaron.ballman, cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D43902 llvm-svn: 327284
2018-03-12 23:42:38 +08:00
Contexts.back().InCpp11AttributeSpecifier = IsCpp11AttributeSpecifier;
clang-format: Lower binding strengths created by the [] created by ObjC method expressions and array literals. They should not bind stronger than regular parentheses or the braces of braced lists. Specific test case in JavaScript: Before: var aaaaa: List< SomeThing> = [new SomeThingAAAAAAAAAAAA(), new SomeThingBBBBBBBBB()]; After: var aaaaa: List<SomeThing> = [ new SomeThingAAAAAAAAAAAA(), new SomeThingBBBBBBBBB() ]; llvm-svn: 238400
2015-05-28 15:21:50 +08:00
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
while (CurrentToken) {
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
if (CurrentToken->is(tok::r_square)) {
[clang-format] Don't detect C++11 attribute specifiers as ObjC Summary: Previously, clang-format would detect C++11 and C++17 attribute specifiers like the following as Objective-C method invocations: [[noreturn]]; [[clang::fallthrough]]; [[noreturn, deprecated("so sorry")]]; [[using gsl: suppress("type")]]; To fix this, I ported part of the logic from tools/clang/lib/Parse/ParseTentative.cpp into TokenAnnotator.cpp so we can explicitly parse and identify C++11 attribute specifiers. This allows the guessLanguage() and getStyle() APIs to correctly guess files containing the C++11 attribute specifiers as C++, not Objective-C. Test Plan: New tests added. Ran tests with: make -j12 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: krasimir, jolesiak, djasper Reviewed By: djasper Subscribers: aaron.ballman, cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D43902 llvm-svn: 327284
2018-03-12 23:42:38 +08:00
if (IsCpp11AttributeSpecifier)
CurrentToken->Type = TT_AttributeSquare;
else if (CurrentToken->Next && CurrentToken->Next->is(tok::l_paren) &&
Left->is(TT_ObjCMethodExpr)) {
Formatter: No space after & and * in front of ObjC message expressions. 1. let determineStarAmp() check of unary operators before checking for "is next '['". That check was added in r173150, and the test from that revision passes either way. 2. change determineStarAmp() to categorize '*' and '&' after '=' as unary operator. 3. don't let parseSquare() overwrite the type of a '*' or '&' before the start of an objc message expression if has the role of unary operator. llvm-svn: 174489
2013-02-06 14:20:11 +08:00
// An ObjC method call is rarely followed by an open parenthesis.
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
// FIXME: Do we incorrectly label ":" with this?
StartsObjCMethodExpr = false;
Left->Type = TT_Unknown;
}
clang-format: Correctly understand arrays of pointers. Before: A<int * []> a; After: A<int *[]> a; This fixes llvm.org/PR19360. llvm-svn: 205761
2014-04-08 21:07:41 +08:00
if (StartsObjCMethodExpr && CurrentToken->Previous != Left) {
Handle nested ObjC calls. Properly handle annotation contexts while calculating extra information for each token. This enable nested ObjC calls and thus solves (most of) llvm.org/PR15164. E.g., we can now format: [contentsContainer replaceSubview:[subviews objectAtIndex:0] with:contentsNativeView]; Also fix a problem with the formatting of types in casts as this was trivial now. llvm-svn: 174498
2013-02-06 18:05:46 +08:00
CurrentToken->Type = TT_ObjCMethodExpr;
[clang-format/ObjC] Correctly annotate single-component ObjC method invocations Summary: Previously, clang-format's parser would fail to annotate the selector in a single-component Objective-C method invocation with `TT_SelectorName`. For example, the following: [foo bar]; would parse `bar` as `TT_Unknown`: M=0 C=1 T=Unknown S=0 B=0 BK=0 P=140 Name=identifier L=34 PPK=2 FakeLParens= FakeRParens=0 II=0x559d5db51770 Text='bar' This caused us to fail to insert a space after a closing cast rparen, so the following: [((Foo *)foo) bar]; would format as: [((Foo *)foo)bar]; This diff fixes the issue by ensuring we annotate the selector in a single-component Objective-C method invocation as `TT_SelectorName`. Test Plan: New tests added. Ran tests with: % make -j16 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: djasper, jolesiak Reviewed By: jolesiak Subscribers: Wizard, klimek, hokein, cfe-commits Differential Revision: https://reviews.llvm.org/D47028 llvm-svn: 332727
2018-05-18 23:27:02 +08:00
// 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->Type = TT_SelectorName;
Formatter: No space after & and * in front of ObjC message expressions. 1. let determineStarAmp() check of unary operators before checking for "is next '['". That check was added in r173150, and the test from that revision passes either way. 2. change determineStarAmp() to categorize '*' and '&' after '=' as unary operator. 3. don't let parseSquare() overwrite the type of a '*' or '&' before the start of an objc message expression if has the role of unary operator. llvm-svn: 174489
2013-02-06 14:20:11 +08:00
// determineStarAmpUsage() thinks that '*' '[' is allocating an
// array of pointers, but if '[' starts a selector then '*' is a
// binary operator.
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Parent && Parent->is(TT_PointerOrReference))
Formatter: Correctly detect ObjC message expressions preceded by a comment. llvm-svn: 174521
2013-02-07 00:54:35 +08:00
Parent->Type = TT_BinaryOperator;
Restructuring of token annotation for formatting. This combines several changes: * Calculation token type (e.g. for * and &) in the AnnotatingParser. * Calculate the scope binding strength in the AnnotatingParser. * Let <> and [] scopes bind stronger than () and {} scopes. * Add minimal debugging output. llvm-svn: 174307
2013-02-04 15:21:18 +08:00
}
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
Left->MatchingParen = CurrentToken;
CurrentToken->MatchingParen = Left;
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
if (Contexts.back().FirstObjCSelectorName) {
Handle nested ObjC calls. Properly handle annotation contexts while calculating extra information for each token. This enable nested ObjC calls and thus solves (most of) llvm.org/PR15164. E.g., we can now format: [contentsContainer replaceSubview:[subviews objectAtIndex:0] with:contentsNativeView]; Also fix a problem with the formatting of types in casts as this was trivial now. llvm-svn: 174498
2013-02-06 18:05:46 +08:00
Contexts.back().FirstObjCSelectorName->LongestObjCSelectorName =
Contexts.back().LongestObjCSelectorName;
[clang-format] Fix ObjC message arguments formatting. Summary: Fixes formatting of ObjC message arguments when inline block is a first argument. Having inline block as a first argument when method has multiple parameters is discouraged by Apple: "It’s best practice to use only one block argument to a method. If the method also needs other non-block arguments, the block should come last" (https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/WorkingwithBlocks/WorkingwithBlocks.html#//apple_ref/doc/uid/TP40011210-CH8-SW7), it should be correctly formatted nevertheless. Current formatting: ``` [object blockArgument:^{ a = 42; } anotherArg:42]; ``` Fixed (colon alignment): ``` [object blockArgument:^{ a = 42; } anotherArg:42]; ``` Test Plan: make -j12 FormatTests && tools/clang/unittests/Format/FormatTests Reviewers: krasimir, benhamilton Reviewed By: krasimir, benhamilton Subscribers: benhamilton, klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D42493 llvm-svn: 324469
2018-02-07 18:35:08 +08:00
Contexts.back().FirstObjCSelectorName->ObjCSelectorNameParts =
Left->ParameterCount;
clang-format: Refactor indentation behavior for multiple nested blocks. This fixes a few oddities when formatting multiple nested JavaScript blocks, e.g.: Before: promise.then( function success() { doFoo(); doBar(); }, [], function error() { doFoo(); doBaz(); }); promise.then([], function success() { doFoo(); doBar(); }, function error() { doFoo(); doBaz(); }); After: promise.then( function success() { doFoo(); doBar(); }, [], function error() { doFoo(); doBaz(); }); promise.then([], function success() { doFoo(); doBar(); }, function error() { doFoo(); doBaz(); }); llvm-svn: 210097
2014-06-03 20:02:45 +08:00
if (Left->BlockParameterCount > 1)
clang-format: Fix various problems in formatting ObjC blocks. Among other things, this fixes llvm.org/PR15269. llvm-svn: 197900
2013-12-23 15:29:06 +08:00
Contexts.back().FirstObjCSelectorName->LongestObjCSelectorName = 0;
}
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
next();
return true;
}
Added AnnotatedToken::isOneOf + a few other refactorings Summary: <subj> Reviewers: djasper Reviewed By: djasper CC: cfe-commits, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D536 llvm-svn: 176951
2013-03-13 22:41:29 +08:00
if (CurrentToken->isOneOf(tok::r_paren, tok::r_brace))
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return false;
clang-format: [ObjC] Fix method expression detection. Before: return (a)[foo bar : baz]; After: return (a)[foo bar:baz]; llvm-svn: 219919
2014-10-16 16:38:51 +08:00
if (CurrentToken->is(tok::colon)) {
[clang-format] Don't detect C++11 attribute specifiers as ObjC Summary: Previously, clang-format would detect C++11 and C++17 attribute specifiers like the following as Objective-C method invocations: [[noreturn]]; [[clang::fallthrough]]; [[noreturn, deprecated("so sorry")]]; [[using gsl: suppress("type")]]; To fix this, I ported part of the logic from tools/clang/lib/Parse/ParseTentative.cpp into TokenAnnotator.cpp so we can explicitly parse and identify C++11 attribute specifiers. This allows the guessLanguage() and getStyle() APIs to correctly guess files containing the C++11 attribute specifiers as C++, not Objective-C. Test Plan: New tests added. Ran tests with: make -j12 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: krasimir, jolesiak, djasper Reviewed By: djasper Subscribers: aaron.ballman, cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D43902 llvm-svn: 327284
2018-03-12 23:42:38 +08:00
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->Type = TT_AttributeColon;
} else if (Left->isOneOf(TT_ArraySubscriptLSquare,
TT_DesignatedInitializerLSquare)) {
clang-format: [ObjC] Fix method expression detection. Before: return (a)[foo bar : baz]; After: return (a)[foo bar:baz]; llvm-svn: 219919
2014-10-16 16:38:51 +08:00
Left->Type = TT_ObjCMethodExpr;
StartsObjCMethodExpr = true;
[clang-format] Fix ObjC message arguments formatting. Summary: Fixes formatting of ObjC message arguments when inline block is a first argument. Having inline block as a first argument when method has multiple parameters is discouraged by Apple: "It’s best practice to use only one block argument to a method. If the method also needs other non-block arguments, the block should come last" (https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/WorkingwithBlocks/WorkingwithBlocks.html#//apple_ref/doc/uid/TP40011210-CH8-SW7), it should be correctly formatted nevertheless. Current formatting: ``` [object blockArgument:^{ a = 42; } anotherArg:42]; ``` Fixed (colon alignment): ``` [object blockArgument:^{ a = 42; } anotherArg:42]; ``` Test Plan: make -j12 FormatTests && tools/clang/unittests/Format/FormatTests Reviewers: krasimir, benhamilton Reviewed By: krasimir, benhamilton Subscribers: benhamilton, klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D42493 llvm-svn: 324469
2018-02-07 18:35:08 +08:00
// ParameterCount might have been set to 1 before expression was
// recognized as ObjCMethodExpr (as '1 + number of commas' formula is
// used for other expression types). Parameter counter has to be,
// therefore, reset to 0.
Left->ParameterCount = 0;
clang-format: [ObjC] Fix method expression detection. Before: return (a)[foo bar : baz]; After: return (a)[foo bar:baz]; llvm-svn: 219919
2014-10-16 16:38:51 +08:00
Contexts.back().ColonIsObjCMethodExpr = true;
if (Parent && Parent->is(tok::r_paren))
[clang-format] Ensure ObjC selectors with 0 args are annotated correctly Summary: Previously, clang-format would incorrectly annotate 0-argument Objective-C selector names as TT_TrailingAnnotation: ``` % echo "-(void)foo;" > /tmp/test.m % ./bin/clang-format -debug /tmp/test.m Language: Objective-C ---- Line(0, FSC=0): minus[T=68, OC=0] l_paren[T=68, OC=1] void[T=68, OC=2] r_paren[T=68, OC=6] identifier[T=68, OC=7] semi[T=68, OC=10] Line(0, FSC=0): eof[T=68, OC=0] Run 0... AnnotatedTokens(L=0): M=0 C=0 T=ObjCMethodSpecifier S=1 B=0 BK=0 P=0 Name=minus L=1 PPK=2 FakeLParens= FakeRParens=0 Text='-' M=0 C=1 T=Unknown S=1 B=0 BK=0 P=33 Name=l_paren L=3 PPK=2 FakeLParens= FakeRParens=0 Text='(' M=0 C=1 T=Unknown S=0 B=0 BK=0 P=140 Name=void L=7 PPK=2 FakeLParens= FakeRParens=0 Text='void' M=0 C=0 T=CastRParen S=0 B=0 BK=0 P=43 Name=r_paren L=8 PPK=2 FakeLParens= FakeRParens=0 Text=')' M=0 C=1 T=TrailingAnnotation S=0 B=0 BK=0 P=120 Name=identifier L=11 PPK=2 FakeLParens= FakeRParens=0 Text='foo' M=0 C=0 T=Unknown S=0 B=0 BK=0 P=23 Name=semi L=12 PPK=2 FakeLParens= FakeRParens=0 Text=';' ``` This caused us to incorrectly indent 0-argument wrapped selectors when Style.IndentWrappedFunctionNames was false, as we thought the 0-argument ObjC selector name was actually a trailing annotation (which is always indented). This diff fixes the issue and adds tests. Test Plan: New tests added. Confirmed tests failed before diff. After diff, tests passed. Ran tests with: % make -j12 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: djasper, jolesiak Reviewed By: djasper, jolesiak Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D44996 llvm-svn: 329297
2018-04-05 23:26:23 +08:00
// FIXME(bug 36976): ObjC return types shouldn't use TT_CastRParen.
clang-format: [ObjC] Fix method expression detection. Before: return (a)[foo bar : baz]; After: return (a)[foo bar:baz]; llvm-svn: 219919
2014-10-16 16:38:51 +08:00
Parent->Type = TT_CastRParen;
}
clang-format: Fix ObjC method exprs with variadic parameters. Before: _versionLabel.text = [ NSString stringWithFormat:NSLocalizedString(@"version: %@", @"Label"), [NSBundle mainBundle].infoDictionary[@"CFBundleShortVersionString"] ]; After: _versionLabel.text = [NSString stringWithFormat:NSLocalizedString(@"version: %@", @"Label"), [NSBundle mainBundle].infoDictionary[@"CFBundleShortVersionString"]]; This fixed llvm.org/PR17695. llvm-svn: 193475
2013-10-27 01:00:22 +08:00
ColonFound = true;
clang-format: [ObjC] Fix method expression detection. Before: return (a)[foo bar : baz]; After: return (a)[foo bar:baz]; llvm-svn: 219919
2014-10-16 16:38:51 +08:00
}
clang-format: Lower binding strengths created by the [] created by ObjC method expressions and array literals. They should not bind stronger than regular parentheses or the braces of braced lists. Specific test case in JavaScript: Before: var aaaaa: List< SomeThing> = [new SomeThingAAAAAAAAAAAA(), new SomeThingBBBBBBBBB()]; After: var aaaaa: List<SomeThing> = [ new SomeThingAAAAAAAAAAAA(), new SomeThingBBBBBBBBB() ]; llvm-svn: 238400
2015-05-28 15:21:50 +08:00
if (CurrentToken->is(tok::comma) && Left->is(TT_ObjCMethodExpr) &&
!ColonFound)
clang-format: Improve formatting of ObjC array literals. Before: NSArray *arguments = @[ kind == kUserTicket ? @"--user-store" : @"--system-store", @"--print-tickets", @"--productid", @"com.google.Chrome" ]; After: NSArray *arguments = @[ kind == kUserTicket ? @"--user-store" : @"--system-store", @"--print-tickets", @"--productid", @"com.google.Chrome" ]; This fixes llvm.org/PR15231. llvm-svn: 193167
2013-10-22 23:30:28 +08:00
Left->Type = TT_ArrayInitializerLSquare;
clang-format: [Java] Support formatting qualified annotations. llvm-svn: 225559
2015-01-10 07:25:06 +08:00
FormatToken *Tok = CurrentToken;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
if (!consumeToken())
return false;
clang-format: Refactor indentation behavior for multiple nested blocks. This fixes a few oddities when formatting multiple nested JavaScript blocks, e.g.: Before: promise.then( function success() { doFoo(); doBar(); }, [], function error() { doFoo(); doBaz(); }); promise.then([], function success() { doFoo(); doBar(); }, function error() { doFoo(); doBaz(); }); After: promise.then( function success() { doFoo(); doBar(); }, [], function error() { doFoo(); doBaz(); }); promise.then([], function success() { doFoo(); doBar(); }, function error() { doFoo(); doBaz(); }); llvm-svn: 210097
2014-06-03 20:02:45 +08:00
updateParameterCount(Left, Tok);
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
}
return false;
}
bool parseBrace() {
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
if (CurrentToken) {
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
FormatToken *Left = CurrentToken->Previous;
clang-format: Force aligning different brackets relative to each other. Before: void SomeFunction(vector< // break int> v); After: void SomeFunction(vector< // break int> v); llvm-svn: 236412
2015-05-04 15:39:00 +08:00
Left->ParentBracket = Contexts.back().ContextKind;
clang-format: Correctly identify ObjC Block with return type. llvm-svn: 204905
2014-03-27 17:43:54 +08:00
if (Contexts.back().CaretFound)
Left->Type = TT_ObjCBlockLBrace;
Contexts.back().CaretFound = false;
clang-format: Cleanup array initializer and dict initializer formatting. Significant changes: - Also recognize these literals with missing "@" for robustness. - Reorganize tests. llvm-svn: 193325
2013-10-24 18:31:50 +08:00
ScopedContextCreator ContextCreator(*this, tok::l_brace, 1);
Contexts.back().ColonIsDictLiteral = true;
clang-format: Correctly identify multiplications in braces init lists. Before: int i{a *b}; After: int i{a * b}; Also fix unrelated issue where braced init lists were counted as blocks and prevented single-line functions. llvm-svn: 209412
2014-05-22 17:00:33 +08:00
if (Left->BlockKind == BK_BracedInit)
Contexts.back().IsExpression = true;
clang-format: [JS] fix union type spacing in object & array types. Summary: Previously, clang-format would insert whitespace in union types nested in object and array types, as it wouldn't recognize those as a type operator: const x: {foo: number | null}; const x: [number | null]; While this is correct for actual binary operators, clang-format should not insert whitespace into union and intersection types to mark those: const x: {foo: number|null}; const x: [number|null]; This change propagates that the context is not an expression by inspecting the preceding token and marking as non-expression if it was a type colon. Reviewers: djasper Subscribers: klimek Differential Revision: https://reviews.llvm.org/D36136 llvm-svn: 310367
2017-08-08 23:00:58 +08:00
if (Style.Language == FormatStyle::LK_JavaScript && Left->Previous &&
Left->Previous->is(TT_JsTypeColon))
Contexts.back().IsExpression = false;
Formatter/ObjC: In dictionary literals, break after ':', not before it. Before: @{ NSFontAttributeNameeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee : regularFont, }; Now: @{ NSFontAttributeNameeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee : regularFont, }; ':'s in dictionary literals (and the corresponding {}s) are now marked as TT_ObjCDictLiteral too, which makes further improvements to dict literal layout possible. llvm-svn: 182716
2013-05-26 13:39:26 +08:00
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
while (CurrentToken) {
Change indentation when breaking after a type. clang-format did not indent any declarations/definitions when breaking after the type. With this change, it indents for all declarations but does not indent for function definitions, i.e.: Before: const SomeLongTypeName& some_long_variable_name; typedef SomeLongTypeName SomeLongTypeAlias; const SomeLongReturnType* SomeLongFunctionName(); const SomeLongReturnType* SomeLongFunctionName() { ... } After: const SomeLongTypeName& some_long_variable_name; typedef SomeLongTypeName SomeLongTypeAlias; const SomeLongReturnType* SomeLongFunctionName(); const SomeLongReturnType* SomeLongFunctionName() { ... } While it might seem inconsistent to indent function declarations, but not definitions, there are two reasons for that: - Function declarations are very similar to declarations of function type variables, so there is another side to consistency to consider. - There can be many function declarations on subsequent lines and not indenting can make them harder to identify. Function definitions are already separated by their body and not indenting makes the function name slighly easier to find. llvm-svn: 181187
2013-05-06 16:27:33 +08:00
if (CurrentToken->is(tok::r_brace)) {
Left->MatchingParen = CurrentToken;
CurrentToken->MatchingParen = Left;
next();
return true;
}
if (CurrentToken->isOneOf(tok::r_paren, tok::r_square))
return false;
updateParameterCount(Left, CurrentToken);
[clang-format] Support <>-style proto message fields Summary: This patch adds support for <>-style proto message fields inside proto options. Previously these were wrongly treated as binary operators and as such were working only by chance for a limited number of cases. Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D34621 llvm-svn: 306406
2017-06-27 21:43:07 +08:00
if (CurrentToken->isOneOf(tok::colon, tok::l_brace, tok::less)) {
clang-format: [proto] Understand text-format nesting without : Before: option (MyProto.options) = { field_c : "OK" msg_field{field_d : 123} }; After: option (MyProto.options) = { field_c : "OK" msg_field{field_d : 123} }; (Note that the colon after "msg_field" is optional). llvm-svn: 215692
2014-08-15 13:00:35 +08:00
FormatToken *Previous = CurrentToken->getPreviousNonComment();
clang-format: [JS] wrap optional properties in type aliases. Summary: clang-format wraps object literal keys in an object literal if they are marked as `TT_SelectorName`s and/or the colon is marked as `TT_DictLiteral`. Previously, clang-format would accidentally work because colons in type aliases were marked as `TT_DictLiteral`. r310367 fixed this to assing `TT_JsTypeColon`, which broke wrapping in certain situations. However the root cause was that clang-format incorrectly didn't skip questionmarks when detecting selector name. This change fixes both locations to (1) assign `TT_SelectorName` and (2) treat `TT_JsTypeColon` like `TT_DictLiteral`. Previously: type X = { a: string, b?: string, }; Now: type X = { a: string, b?: string, }; Reviewers: djasper, sammccall Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D36684 llvm-svn: 310852
2017-08-15 00:09:08 +08:00
if (Previous->is(TT_JsTypeOptionalQuestion))
Previous = Previous->getPreviousNonComment();
[clang-format] Fixes indentation of inner text proto messages Summary: Consider the text proto: ``` message { sub { key: value } } ``` Previously the first `{` was TT_Unknown, which caused the inner message to be indented by the continuation width. This didn't happen for: ``` message { sub: { key: value } } ``` This is because the code to mark the first `{` as a TT_DictLiteral was only considering the case where it marches forward and reaches a `:`. This patch updates this by looking not only for `:`, but also for `<` and `{`. Reviewers: djasper Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D42500 llvm-svn: 323419
2018-01-25 22:10:43 +08:00
if ((CurrentToken->is(tok::colon) &&
(!Contexts.back().ColonIsDictLiteral || !Style.isCpp())) ||
Style.Language == FormatStyle::LK_Proto ||
Style.Language == FormatStyle::LK_TextProto) {
Left->Type = TT_DictLiteral;
if (Previous->Tok.getIdentifierInfo() ||
Previous->is(tok::string_literal))
Previous->Type = TT_SelectorName;
}
clang-format: [JS] Understand object literals with only methods. Before: let theObject = {someMethodName() { doTheThing(); doTheOtherThing(); }, someOtherMethodName() { doSomething(); doSomethingElse(); }}; After: let theObject = { someMethodName() { doTheThing(); doTheOtherThing(); }, someOtherMethodName() { doSomething(); doSomethingElse(); } }; llvm-svn: 234091
2015-04-04 15:56:55 +08:00
if (CurrentToken->is(tok::colon) ||
Style.Language == FormatStyle::LK_JavaScript)
clang-format: [proto] Understand text-format nesting without : Before: option (MyProto.options) = { field_c : "OK" msg_field{field_d : 123} }; After: option (MyProto.options) = { field_c : "OK" msg_field{field_d : 123} }; (Note that the colon after "msg_field" is optional). llvm-svn: 215692
2014-08-15 13:00:35 +08:00
Left->Type = TT_DictLiteral;
clang-format: [JS] Treat dict literals similar to objc method exprs. Before: return { link: function() { f(); // } }; return { a: a, link: function() { f(); // } } After: return { link: function() { f(); // } }; return { a: a, link: function() { f(); // } }; llvm-svn: 210537
2014-06-10 22:44:02 +08:00
}
clang-format: [JS] Properly format dict literals that skip labels. llvm-svn: 288121
2016-11-29 17:40:36 +08:00
if (CurrentToken->is(tok::comma) &&
Style.Language == FormatStyle::LK_JavaScript)
Left->Type = TT_DictLiteral;
Change indentation when breaking after a type. clang-format did not indent any declarations/definitions when breaking after the type. With this change, it indents for all declarations but does not indent for function definitions, i.e.: Before: const SomeLongTypeName& some_long_variable_name; typedef SomeLongTypeName SomeLongTypeAlias; const SomeLongReturnType* SomeLongFunctionName(); const SomeLongReturnType* SomeLongFunctionName() { ... } After: const SomeLongTypeName& some_long_variable_name; typedef SomeLongTypeName SomeLongTypeAlias; const SomeLongReturnType* SomeLongFunctionName(); const SomeLongReturnType* SomeLongFunctionName() { ... } While it might seem inconsistent to indent function declarations, but not definitions, there are two reasons for that: - Function declarations are very similar to declarations of function type variables, so there is another side to consistency to consider. - There can be many function declarations on subsequent lines and not indenting can make them harder to identify. Function definitions are already separated by their body and not indenting makes the function name slighly easier to find. llvm-svn: 181187
2013-05-06 16:27:33 +08:00
if (!consumeToken())
return false;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
}
}
Revert "[clang-format] Improve Incomplete detection for (text) protos" This reverts commit r330016. The incomplete detection has too many false positives, picking up typos for hard failures and refusing to format anything in that case. llvm-svn: 330569
2018-04-23 16:50:36 +08:00
return true;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
}
Don't remove blank lines within unwrapped lines. If the code author decides to put empty lines anywhere into the code we should treat them equally, i.e. reduce them to the configured MaxEmptyLinesToKeep. With this change, we e.g. keep the newline in: SomeType ST = { // First value a, // Second value b }; llvm-svn: 175620
2013-02-20 20:56:39 +08:00
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
void updateParameterCount(FormatToken *Left, FormatToken *Current) {
clang-format: [JS] Don't count shortened object literals as blocks. Before: f({a}, () => { g(); // }); After: f({a}, () => { g(); // }); llvm-svn: 260060
2016-02-08 06:17:13 +08:00
if (Current->is(tok::l_brace) && Current->BlockKind == BK_Block)
clang-format: Refactor indentation behavior for multiple nested blocks. This fixes a few oddities when formatting multiple nested JavaScript blocks, e.g.: Before: promise.then( function success() { doFoo(); doBar(); }, [], function error() { doFoo(); doBaz(); }); promise.then([], function success() { doFoo(); doBar(); }, function error() { doFoo(); doBaz(); }); After: promise.then( function success() { doFoo(); doBar(); }, [], function error() { doFoo(); doBaz(); }); promise.then([], function success() { doFoo(); doBar(); }, function error() { doFoo(); doBaz(); }); llvm-svn: 210097
2014-06-03 20:02:45 +08:00
++Left->BlockParameterCount;
[clang-format] Fix ObjC message arguments formatting. Summary: Fixes formatting of ObjC message arguments when inline block is a first argument. Having inline block as a first argument when method has multiple parameters is discouraged by Apple: "It’s best practice to use only one block argument to a method. If the method also needs other non-block arguments, the block should come last" (https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/WorkingwithBlocks/WorkingwithBlocks.html#//apple_ref/doc/uid/TP40011210-CH8-SW7), it should be correctly formatted nevertheless. Current formatting: ``` [object blockArgument:^{ a = 42; } anotherArg:42]; ``` Fixed (colon alignment): ``` [object blockArgument:^{ a = 42; } anotherArg:42]; ``` Test Plan: make -j12 FormatTests && tools/clang/unittests/Format/FormatTests Reviewers: krasimir, benhamilton Reviewed By: krasimir, benhamilton Subscribers: benhamilton, klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D42493 llvm-svn: 324469
2018-02-07 18:35:08 +08:00
if (Left->Type == TT_ObjCMethodExpr) {
if (Current->is(tok::colon))
++Left->ParameterCount;
} else if (Current->is(tok::comma)) {
Fix counting of parameters so that r175162 works as expected. Before: aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa() .aaaaaaaaaaaaaaaaa()); After: aaaaaaaaaaaaaaaaaaaaaaaaa( aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa()); Not sure which of the formattings above is better, but we should not pick one by accident. llvm-svn: 175165
2013-02-14 23:01:34 +08:00
++Left->ParameterCount;
clang-format: Add column layout formatting for braced lists With this patch, braced lists (with more than 3 elements are formatted in a column layout if possible). E.g.: static const uint16_t CallerSavedRegs64Bit[] = { X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI, X86::R8, X86::R9, X86::R10, X86::R11, 0 }; Required other changes: - FormatTokens can now have a special role that contains extra data and can do special formattings. A comma separated list is currently the only implementation. - Move penalty calculation entirely into ContinuationIndenter (there was a last piece still in UnwrappedLineFormatter). Review: http://llvm-reviews.chandlerc.com/D1457 llvm-svn: 189018
2013-08-22 23:00:41 +08:00
if (!Left->Role)
Left->Role.reset(new CommaSeparatedList(Style));
Left->Role->CommaFound(Current);
Add experimental flag for adaptive parameter bin-packing. This is not activated for any style, might change or go away completely. For those that want to play around with it, set ExperimentalAutoDetectBinPacking to true. clang-format will then: Look at whether function calls/declarations/definitions are currently formatted with one parameter per line (on a case-by-case basis). If so, clang-format will avoid bin-packing the parameters. If all parameters are on one line (thus that line is "inconclusive"), clang-format will make the choice dependent on whether there are other bin-packed calls/declarations in the same file. The reason for this change is that bin-packing in some situations can be really bad and an author might opt to put one parameter on each line. If the author does that, he might want clang-format not to mess with that. If the author is unhappy with the one-per-line formatting, clang-format can easily be convinced to bin-pack by putting any two parameters on the same line. llvm-svn: 186003
2013-07-10 22:02:49 +08:00
} else if (Left->ParameterCount == 0 && Current->isNot(tok::comment)) {
Fix counting of parameters so that r175162 works as expected. Before: aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa() .aaaaaaaaaaaaaaaaa()); After: aaaaaaaaaaaaaaaaaaaaaaaaa( aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa()); Not sure which of the formattings above is better, but we should not pick one by accident. llvm-svn: 175165
2013-02-14 23:01:34 +08:00
Left->ParameterCount = 1;
Add experimental flag for adaptive parameter bin-packing. This is not activated for any style, might change or go away completely. For those that want to play around with it, set ExperimentalAutoDetectBinPacking to true. clang-format will then: Look at whether function calls/declarations/definitions are currently formatted with one parameter per line (on a case-by-case basis). If so, clang-format will avoid bin-packing the parameters. If all parameters are on one line (thus that line is "inconclusive"), clang-format will make the choice dependent on whether there are other bin-packed calls/declarations in the same file. The reason for this change is that bin-packing in some situations can be really bad and an author might opt to put one parameter on each line. If the author does that, he might want clang-format not to mess with that. If the author is unhappy with the one-per-line formatting, clang-format can easily be convinced to bin-pack by putting any two parameters on the same line. llvm-svn: 186003
2013-07-10 22:02:49 +08:00
}
Fix counting of parameters so that r175162 works as expected. Before: aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa() .aaaaaaaaaaaaaaaaa()); After: aaaaaaaaaaaaaaaaaaaaaaaaa( aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa()); Not sure which of the formattings above is better, but we should not pick one by accident. llvm-svn: 175165
2013-02-14 23:01:34 +08:00
}
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
bool parseConditional() {
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
while (CurrentToken) {
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
if (CurrentToken->is(tok::colon)) {
CurrentToken->Type = TT_ConditionalExpr;
next();
return true;
}
if (!consumeToken())
return false;
}
return false;
}
bool parseTemplateDeclaration() {
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
if (CurrentToken && CurrentToken->is(tok::less)) {
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
CurrentToken->Type = TT_TemplateOpener;
next();
if (!parseAngle())
return false;
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
if (CurrentToken)
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
CurrentToken->Previous->ClosesTemplateDeclaration = true;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return true;
}
return false;
}
bool consumeToken() {
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
FormatToken *Tok = CurrentToken;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
next();
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
switch (Tok->Tok.getKind()) {
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
case tok::plus:
case tok::minus:
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
if (!Tok->Previous && Line.MustBeDeclaration)
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
Tok->Type = TT_ObjCMethodSpecifier;
break;
case tok::colon:
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
if (!Tok->Previous)
Fix clang-format segfault. When annotating "lines" starting with ":", clang-format would segfault. This could actually happen in valid code, e.g. #define A : llvm-svn: 177283
2013-03-18 20:50:26 +08:00
return false;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
// Colons from ?: are handled in parseConditional().
clang-format: [JS] support optionality markers in JS types. Patch by Martin Probst. Thank you. llvm-svn: 234753
2015-04-13 23:01:40 +08:00
if (Style.Language == FormatStyle::LK_JavaScript) {
clang-format: [JS] support optional methods. Optional methods use ? tokens like this: interface X { y?(): z; } It seems easiest to detect and disambiguate these from ternary expressions by checking if the code is in a declaration context. Turns out that that didn't quite work properly for interfaces in Java and JS, and for JS file root contexts. Patch by Martin Probst, thank you. llvm-svn: 236488
2015-05-05 16:40:32 +08:00
if (Contexts.back().ColonIsForRangeExpr || // colon in for loop
(Contexts.size() == 1 && // switch/case labels
clang-format: [JS] support optionality markers in JS types. Patch by Martin Probst. Thank you. llvm-svn: 234753
2015-04-13 23:01:40 +08:00
!Line.First->isOneOf(tok::kw_enum, tok::kw_case)) ||
clang-format: [JS] support optional methods. Optional methods use ? tokens like this: interface X { y?(): z; } It seems easiest to detect and disambiguate these from ternary expressions by checking if the code is in a declaration context. Turns out that that didn't quite work properly for interfaces in Java and JS, and for JS file root contexts. Patch by Martin Probst, thank you. llvm-svn: 236488
2015-05-05 16:40:32 +08:00
Contexts.back().ContextKind == tok::l_paren || // function params
Contexts.back().ContextKind == tok::l_square || // array type
clang-format: [JS] fix union type spacing in object & array types. Summary: Previously, clang-format would insert whitespace in union types nested in object and array types, as it wouldn't recognize those as a type operator: const x: {foo: number | null}; const x: [number | null]; While this is correct for actual binary operators, clang-format should not insert whitespace into union and intersection types to mark those: const x: {foo: number|null}; const x: [number|null]; This change propagates that the context is not an expression by inspecting the preceding token and marking as non-expression if it was a type colon. Reviewers: djasper Subscribers: klimek Differential Revision: https://reviews.llvm.org/D36136 llvm-svn: 310367
2017-08-08 23:00:58 +08:00
(!Contexts.back().IsExpression &&
Contexts.back().ContextKind == tok::l_brace) || // object type
clang-format: [JS] Fix bug in type colon detection. Before, this couldn't be formatted at all: class X { subs = { 'b': { 'c': 1, }, }; } llvm-svn: 238907
2015-06-03 16:43:18 +08:00
(Contexts.size() == 1 &&
Line.MustBeDeclaration)) { // method/property declaration
clang-format: [JS] handle union types in arrow functions. Summary: clang-format would previously fail to detect that an arrow functions parameter block is not an expression, and thus insert whitespace around the `|` and `&` type operators in it. Reviewers: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D36147 llvm-svn: 309707
2017-08-02 01:19:32 +08:00
Contexts.back().IsExpression = false;
clang-format: [JS] support optionality markers in JS types. Patch by Martin Probst. Thank you. llvm-svn: 234753
2015-04-13 23:01:40 +08:00
Tok->Type = TT_JsTypeColon;
break;
}
}
clang-format: [Proto] Basic support for options with <> for repeated fields. llvm-svn: 256737
2016-01-04 15:28:12 +08:00
if (Contexts.back().ColonIsDictLiteral ||
[clang-format] Support text proto messages Summary: This patch adds support for textual protocol buffer messages. Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek, mgorny Differential Revision: https://reviews.llvm.org/D34441 llvm-svn: 307029
2017-07-03 23:05:14 +08:00
Style.Language == FormatStyle::LK_Proto ||
Style.Language == FormatStyle::LK_TextProto) {
clang-format: Cleanup array initializer and dict initializer formatting. Significant changes: - Also recognize these literals with missing "@" for robustness. - Reorganize tests. llvm-svn: 193325
2013-10-24 18:31:50 +08:00
Tok->Type = TT_DictLiteral;
[clang-format] Support text proto messages Summary: This patch adds support for textual protocol buffer messages. Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek, mgorny Differential Revision: https://reviews.llvm.org/D34441 llvm-svn: 307029
2017-07-03 23:05:14 +08:00
if (Style.Language == FormatStyle::LK_TextProto) {
if (FormatToken *Previous = Tok->getPreviousNonComment())
Previous->Type = TT_SelectorName;
}
Handle nested ObjC calls. Properly handle annotation contexts while calculating extra information for each token. This enable nested ObjC calls and thus solves (most of) llvm.org/PR15164. E.g., we can now format: [contentsContainer replaceSubview:[subviews objectAtIndex:0] with:contentsNativeView]; Also fix a problem with the formatting of types in casts as this was trivial now. llvm-svn: 174498
2013-02-06 18:05:46 +08:00
} else if (Contexts.back().ColonIsObjCMethodExpr ||
clang-format: NFC. Add a function to test whether an annotated line starts with a given sequence of tokens. Only the one-token version is used yet, but other usages are coming up momentarily. llvm-svn: 239892
2015-06-17 17:43:56 +08:00
Line.startsWith(TT_ObjCMethodSpecifier)) {
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
Tok->Type = TT_ObjCMethodExpr;
clang-format: Support ObjC selectors with unnamed parameters. This fixes llvm.org/PR28063. llvm-svn: 286715
2016-11-12 15:38:22 +08:00
const FormatToken *BeforePrevious = Tok->Previous->Previous;
[clang-format/ObjC] Fix NS_SWIFT_NAME(foo(bar:baz:)) after ObjC method decl Summary: In D44638, I partially fixed `NS_SWIFT_NAME(foo(bar:baz:))`-style annotations on C functions, but didn't add a test for Objective-C method declarations. For ObjC method declarations which are annotated with `NS_SWIFT_NAME(...)`, we currently fail to annotate the final component of the selector name as `TT_SelectorName`. Because the token type is left unknown, clang-format will happily cause a compilation error when it changes the following: ``` @interface Foo - (void)doStuffWithFoo:(id)name bar:(id)bar baz:(id)baz NS_SWIFT_NAME(doStuff(withFoo:bar:baz:)); @end ``` to: ``` @interface Foo - (void)doStuffWithFoo:(id)name bar:(id)bar baz:(id)baz NS_SWIFT_NAME(doStuff(withFoo:bar:baz :)); @end ``` (note the linebreak before the final `:`). The logic which decides whether or not to annotate the token before a `:` with `TT_SelectorName` is pretty fragile, and has to handle some pretty odd cases like pair-parameters: ``` [I drawRectOn:surface ofSize:aa:bbb atOrigin:cc:dd]; ``` So, to minimize the effect of this change, I decided to only annotate unknown identifiers before a `:` as `TT_SelectorName` for Objective-C declaration lines. Test Plan: New tests included. Confirmed tests failed before change and passed after change. Ran tests with: % make -j16 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: djasper, krasimir, jolesiak Reviewed By: krasimir Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D48679 llvm-svn: 335983
2018-06-29 23:26:37 +08:00
// 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);
clang-format: Support ObjC selectors with unnamed parameters. This fixes llvm.org/PR28063. llvm-svn: 286715
2016-11-12 15:38:22 +08:00
if (!BeforePrevious ||
[clang-format] Ensure ObjC selectors with 0 args are annotated correctly Summary: Previously, clang-format would incorrectly annotate 0-argument Objective-C selector names as TT_TrailingAnnotation: ``` % echo "-(void)foo;" > /tmp/test.m % ./bin/clang-format -debug /tmp/test.m Language: Objective-C ---- Line(0, FSC=0): minus[T=68, OC=0] l_paren[T=68, OC=1] void[T=68, OC=2] r_paren[T=68, OC=6] identifier[T=68, OC=7] semi[T=68, OC=10] Line(0, FSC=0): eof[T=68, OC=0] Run 0... AnnotatedTokens(L=0): M=0 C=0 T=ObjCMethodSpecifier S=1 B=0 BK=0 P=0 Name=minus L=1 PPK=2 FakeLParens= FakeRParens=0 Text='-' M=0 C=1 T=Unknown S=1 B=0 BK=0 P=33 Name=l_paren L=3 PPK=2 FakeLParens= FakeRParens=0 Text='(' M=0 C=1 T=Unknown S=0 B=0 BK=0 P=140 Name=void L=7 PPK=2 FakeLParens= FakeRParens=0 Text='void' M=0 C=0 T=CastRParen S=0 B=0 BK=0 P=43 Name=r_paren L=8 PPK=2 FakeLParens= FakeRParens=0 Text=')' M=0 C=1 T=TrailingAnnotation S=0 B=0 BK=0 P=120 Name=identifier L=11 PPK=2 FakeLParens= FakeRParens=0 Text='foo' M=0 C=0 T=Unknown S=0 B=0 BK=0 P=23 Name=semi L=12 PPK=2 FakeLParens= FakeRParens=0 Text=';' ``` This caused us to incorrectly indent 0-argument wrapped selectors when Style.IndentWrappedFunctionNames was false, as we thought the 0-argument ObjC selector name was actually a trailing annotation (which is always indented). This diff fixes the issue and adds tests. Test Plan: New tests added. Confirmed tests failed before diff. After diff, tests passed. Ran tests with: % make -j12 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: djasper, jolesiak Reviewed By: djasper, jolesiak Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D44996 llvm-svn: 329297
2018-04-05 23:26:23 +08:00
// FIXME(bug 36976): ObjC return types shouldn't use TT_CastRParen.
clang-format: Support ObjC selectors with unnamed parameters. This fixes llvm.org/PR28063. llvm-svn: 286715
2016-11-12 15:38:22 +08:00
!(BeforePrevious->is(TT_CastRParen) ||
(BeforePrevious->is(TT_ObjCMethodExpr) &&
BeforePrevious->is(tok::colon))) ||
BeforePrevious->is(tok::r_square) ||
[clang-format/ObjC] Fix NS_SWIFT_NAME(foo(bar:baz:)) after ObjC method decl Summary: In D44638, I partially fixed `NS_SWIFT_NAME(foo(bar:baz:))`-style annotations on C functions, but didn't add a test for Objective-C method declarations. For ObjC method declarations which are annotated with `NS_SWIFT_NAME(...)`, we currently fail to annotate the final component of the selector name as `TT_SelectorName`. Because the token type is left unknown, clang-format will happily cause a compilation error when it changes the following: ``` @interface Foo - (void)doStuffWithFoo:(id)name bar:(id)bar baz:(id)baz NS_SWIFT_NAME(doStuff(withFoo:bar:baz:)); @end ``` to: ``` @interface Foo - (void)doStuffWithFoo:(id)name bar:(id)bar baz:(id)baz NS_SWIFT_NAME(doStuff(withFoo:bar:baz :)); @end ``` (note the linebreak before the final `:`). The logic which decides whether or not to annotate the token before a `:` with `TT_SelectorName` is pretty fragile, and has to handle some pretty odd cases like pair-parameters: ``` [I drawRectOn:surface ofSize:aa:bbb atOrigin:cc:dd]; ``` So, to minimize the effect of this change, I decided to only annotate unknown identifiers before a `:` as `TT_SelectorName` for Objective-C declaration lines. Test Plan: New tests included. Confirmed tests failed before change and passed after change. Ran tests with: % make -j16 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: djasper, krasimir, jolesiak Reviewed By: krasimir Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D48679 llvm-svn: 335983
2018-06-29 23:26:37 +08:00
Contexts.back().LongestObjCSelectorName == 0 ||
UnknownIdentifierInMethodDeclaration) {
clang-format: Support ObjC selectors with unnamed parameters. This fixes llvm.org/PR28063. llvm-svn: 286715
2016-11-12 15:38:22 +08:00
Tok->Previous->Type = TT_SelectorName;
if (!Contexts.back().FirstObjCSelectorName)
Contexts.back().FirstObjCSelectorName = Tok->Previous;
clang-format: keep ObjC colon alignment with short object name Summary: When the target object expression is short and the first selector name is long, clang-format used to break the colon alignment: [I performSelectorOnMainThread:@selector(loadAccessories) withObject:nil waitUntilDone:false]; This happens because the colon is placed at `ContinuationIndent + LongestObjCSelectorName`, so that any selector can be wrapped. This is however not needed in case the longest selector is the firstone, and not wrapped. To overcome this, this patch does not include the first selector in `LongestObjCSelectorName` computation (in TokenAnnotator), and lets `ContinuationIndenter` decide how to account for the first selector when wrapping. (Note this was already partly the case, see line 521 of ContinuationIndenter.cpp) This way, the code gets properly aligned whenever possible without breaking the continuation indent. [I performSelectorOnMainThread:@selector(loadAccessories) withObject:nil waitUntilDone:false]; [I // force break performSelectorOnMainThread:@selector(loadAccessories) withObject:nil waitUntilDone:false]; [I perform:@selector(loadAccessories) withSelectorOnMainThread:true waitUntilDone:false]; Reviewers: krasimir, djasper, klimek Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D43121 llvm-svn: 324741
2018-02-09 23:41:56 +08:00
else if (Tok->Previous->ColumnWidth >
Contexts.back().LongestObjCSelectorName)
Contexts.back().LongestObjCSelectorName =
Tok->Previous->ColumnWidth;
clang-format: Support ObjC selectors with unnamed parameters. This fixes llvm.org/PR28063. llvm-svn: 286715
2016-11-12 15:38:22 +08:00
}
Handle nested ObjC calls. Properly handle annotation contexts while calculating extra information for each token. This enable nested ObjC calls and thus solves (most of) llvm.org/PR15164. E.g., we can now format: [contentsContainer replaceSubview:[subviews objectAtIndex:0] with:contentsNativeView]; Also fix a problem with the formatting of types in casts as this was trivial now. llvm-svn: 174498
2013-02-06 18:05:46 +08:00
} else if (Contexts.back().ColonIsForRangeExpr) {
clang-format: [JS] support optionality markers in JS types. Patch by Martin Probst. Thank you. llvm-svn: 234753
2015-04-13 23:01:40 +08:00
Tok->Type = TT_RangeBasedForLoopColon;
clang-format: Fix bug introduced by r208392. Also run clang-format over clang-format's files. llvm-svn: 208409
2014-05-09 21:11:16 +08:00
} else if (CurrentToken && CurrentToken->is(tok::numeric_constant)) {
Correctly detect colon in bit fields. Fixes PR17333. Summary: Colon was incorrectly detected as a start of inheritance list. Fixed. Reviewers: djasper Reviewed By: djasper CC: cfe-commits, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D1884 llvm-svn: 192349
2013-10-10 21:36:20 +08:00
Tok->Type = TT_BitFieldColon;
clang-format: Don't break before a case's colon. Before (with just the right line length: switch (a) { case some_namespace::some_constant : return; } After: switch (a) { case some_namespace:: some_constant: return; } llvm-svn: 209725
2014-05-28 18:09:11 +08:00
} else if (Contexts.size() == 1 &&
!Line.First->isOneOf(tok::kw_enum, tok::kw_case)) {
[Format] Cleanup after replacing constructor body with = default Summary: Remove colon and commas after replacing constructor body with = default. Fix annotation of TT_CtorInitializerColon when preceded by a comment. Reviewers: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D25768 llvm-svn: 284732
2016-10-20 22:58:45 +08:00
if (Tok->getPreviousNonComment()->isOneOf(tok::r_paren,
tok::kw_noexcept))
clang-format: [JS] Support type annotations. This patch adds support for type annotations that follow TypeScript's, Flow's, and AtScript's syntax style. Patch by Martin Probst, thank you. Review: http://reviews.llvm.org/D7721 llvm-svn: 229700
2015-02-19 01:09:53 +08:00
Tok->Type = TT_CtorInitializerColon;
else
Tok->Type = TT_InheritanceColon;
[clang-format/ObjC] Use getIdentifierInfo() instead of tok::identifier Summary: Previously, we checked tokens for `tok::identifier` to see if they were identifiers inside an Objective-C selector. However, this missed C++ keywords like `new` and `delete`. To fix this, this diff uses `getIdentifierInfo()` to find identifiers or keywords inside Objective-C selectors. Test Plan: New tests added. Ran tests with: % make -j16 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: djasper, jolesiak Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D46143 llvm-svn: 331067
2018-04-28 02:51:12 +08:00
} else if (canBeObjCSelectorComponent(*Tok->Previous) && Tok->Next &&
[clang-format] Fix ObjC selectors with multiple params passed to macro Summary: Objective-C selectors with arguments take the form of: foo: foo:bar: foo:bar:baz: These can be passed to a macro, like NS_SWIFT_NAME(): https://developer.apple.com/library/content/documentation/Swift/Conceptual/BuildingCocoaApps/MixandMatch.html and must never have spaces inserted around the colons. Previously, there was logic in TokenAnnotator's tok::colon parser to handle the single-argument case, but it failed for the multiple-argument cases. This diff fixes the bug and adds more tests. Test Plan: New tests added. Ran tests with: % make -j12 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: jolesiak, djasper, Wizard Reviewed By: jolesiak, Wizard Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D44638 llvm-svn: 327986
2018-03-20 22:53:25 +08:00
(Tok->Next->isOneOf(tok::r_paren, tok::comma) ||
[clang-format/ObjC] Use getIdentifierInfo() instead of tok::identifier Summary: Previously, we checked tokens for `tok::identifier` to see if they were identifiers inside an Objective-C selector. However, this missed C++ keywords like `new` and `delete`. To fix this, this diff uses `getIdentifierInfo()` to find identifiers or keywords inside Objective-C selectors. Test Plan: New tests added. Ran tests with: % make -j16 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: djasper, jolesiak Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D46143 llvm-svn: 331067
2018-04-28 02:51:12 +08:00
(canBeObjCSelectorComponent(*Tok->Next) && Tok->Next->Next &&
Tok->Next->Next->is(tok::colon)))) {
clang-format: [ObjC] Fix using selector names as macro arguments. Before: [self aaaaa:MACRO(a, b :, c :)]; After: [self aaaaa:MACRO(a, b:, c:)]; llvm-svn: 220197
2014-10-20 20:01:45 +08:00
// This handles a special macro in ObjC code where selectors including
// the colon are passed as macro arguments.
Tok->Type = TT_ObjCMethodExpr;
Basic support for formatting asm() statments. llvm-svn: 177073
2013-03-14 21:45:21 +08:00
} else if (Contexts.back().ContextKind == tok::l_paren) {
clang-format: [JS] support optionality markers in JS types. Patch by Martin Probst. Thank you. llvm-svn: 234753
2015-04-13 23:01:40 +08:00
Tok->Type = TT_InlineASMColon;
Initial support for formatting ObjC method declarations/calls. We can now format stuff like: - (void)doSomethingWith:(GTMFoo *)theFoo rect:(NSRect)theRect interval:(float)theInterval { [myObject doFooWith:arg1 // name:arg2 error:arg3]; } This seems to fix everything mentioned in llvm.org/PR14939. llvm-svn: 174364
2013-02-05 18:07:47 +08:00
}
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
break;
clang-format: [JS] no space in union and intersection types. The operators | and & in types, as opposed to the bitwise operators, should not have whitespace around them (e.g. `Foo<Bar|Baz>`). Patch by Martin Probst. Thank you. llvm-svn: 263961
2016-03-22 01:57:31 +08:00
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->Type = TT_JsTypeOperator;
break;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
case tok::kw_if:
case tok::kw_while:
clang-format clang-format. llvm-svn: 313744
2017-09-20 17:51:03 +08:00
if (Tok->is(tok::kw_if) && CurrentToken &&
CurrentToken->is(tok::kw_constexpr))
clang-format: Handle "if constexpr". c++1z adds the following constructions to the language: if constexpr (cond) statement1; else if constexpr (cond) statement2; else if constexpr (cond) statement3; else statement4; A first version of this was proposed in reviews.llvm.org/D26953 by Francis Visoiu Mistrih, but never commited. This patch additionally fixes the behavior when allowing short if statements on a single line and was authored by Jacob Bandes-Storch. Thank you to both authors. llvm-svn: 305666
2017-06-19 15:40:49 +08:00
next();
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
if (CurrentToken && CurrentToken->is(tok::l_paren)) {
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
next();
Run clang-format on lib/Format code after r184894. No other changes. llvm-svn: 184896
2013-06-26 08:30:14 +08:00
if (!parseParens(/*LookForDecls=*/true))
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return false;
}
break;
case tok::kw_for:
[Format] Add curly braces to suppress a -Wmisleading-indentation warning from gcc. llvm-svn: 303501
2017-05-21 15:29:07 +08:00
if (Style.Language == FormatStyle::LK_JavaScript) {
clang-format: [JS] handle `for` as object label. Summary: Previously, clang-format would fail formatting `{for: 1}`. Reviewers: djasper Subscribers: klimek Differential Revision: https://reviews.llvm.org/D40441 llvm-svn: 318974
2017-11-25 17:24:33 +08:00
// x.for and {for: ...}
if ((Tok->Previous && Tok->Previous->is(tok::period)) ||
(Tok->Next && Tok->Next->is(tok::colon)))
clang-format: [JS] for async loops. Summary: JavaScript supports asynchronous loop iteration in async functions: for async (const x of y) ... Reviewers: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D33193 llvm-svn: 303106
2017-05-16 03:33:20 +08:00
break;
clang-format: [JS] for await, and fix a crash with for loops. Summary: The syntax is actually `for await (const x of y)` (d'oh). This also fixes a crash for `for` tokens not followed by additional tokens. Reviewers: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D33329 llvm-svn: 303382
2017-05-19 05:19:29 +08:00
// JS' for await ( ...
if (CurrentToken && CurrentToken->is(Keywords.kw_await))
clang-format: [JS] for async loops. Summary: JavaScript supports asynchronous loop iteration in async functions: for async (const x of y) ... Reviewers: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D33193 llvm-svn: 303106
2017-05-16 03:33:20 +08:00
next();
[Format] Add curly braces to suppress a -Wmisleading-indentation warning from gcc. llvm-svn: 303501
2017-05-21 15:29:07 +08:00
}
Handle nested ObjC calls. Properly handle annotation contexts while calculating extra information for each token. This enable nested ObjC calls and thus solves (most of) llvm.org/PR15164. E.g., we can now format: [contentsContainer replaceSubview:[subviews objectAtIndex:0] with:contentsNativeView]; Also fix a problem with the formatting of types in casts as this was trivial now. llvm-svn: 174498
2013-02-06 18:05:46 +08:00
Contexts.back().ColonIsForRangeExpr = true;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
next();
if (!parseParens())
return false;
break;
case tok::l_paren:
clang-format: Fix return type breaking with overloaded operator functions Differential Revision: http://reviews.llvm.org/D11177 llvm-svn: 242316
2015-07-16 03:11:58 +08:00
// 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.
clang-format clang-format. llvm-svn: 313744
2017-09-20 17:51:03 +08:00
if (Tok->Previous && Tok->Previous->is(tok::r_paren) &&
clang-format: Fix return type breaking with overloaded operator functions Differential Revision: http://reviews.llvm.org/D11177 llvm-svn: 242316
2015-07-16 03:11:58 +08:00
Tok->Previous->MatchingParen &&
Tok->Previous->MatchingParen->is(TT_OverloadedOperatorLParen)) {
Tok->Previous->Type = TT_OverloadedOperator;
Tok->Previous->MatchingParen->Type = TT_OverloadedOperator;
Tok->Type = TT_OverloadedOperatorLParen;
}
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
if (!parseParens())
return false;
clang-format: Remove old hack that mainly made incorrect tests pass. As a side-effect, constructors definitions will correctly be recognized and formatted as function declarations. Tests will be added in a follow-up patch actually using the correct recognition. llvm-svn: 194209
2013-11-08 01:43:07 +08:00
if (Line.MustBeDeclaration && Contexts.size() == 1 &&
clang-format: NFC. Add a function to test whether an annotated line starts with a given sequence of tokens. Only the one-token version is used yet, but other usages are coming up momentarily. llvm-svn: 239892
2015-06-17 17:43:56 +08:00
!Contexts.back().IsExpression && !Line.startsWith(TT_ObjCProperty) &&
clang-format: [Java] Don't get confused by leading annotations. Before: @Test(a) aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaa( aaaaaaaaaaaaaaaaaaaaaaa); After: @Test(a) aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa); llvm-svn: 225962
2015-01-14 17:47:57 +08:00
(!Tok->Previous ||
clang-format: Fix __attribute__ being treated as decl name. __attribute__ was treated as the name of a function definition, with the tokens in parentheses being the parameter list. This formats incorrectly with AlwaysBreakAfterDefinitionReturnType. Fix it by treating __attribute__ like decltype. Patch by Strager Neds, thank you. llvm-svn: 241439
2015-07-06 19:30:34 +08:00
!Tok->Previous->isOneOf(tok::kw_decltype, tok::kw___attribute,
TT_LeadingJavaAnnotation)))
Allow breaking between a type and name in variable declarations. This fixes llvm.org/PR14967 and is generall necessary to avoid situations where the column limit is exceeded. The challenge is restricting such lines splits, otherwise clang-format suddenly starts breaking at bad places. Before: ReallyLongReturnType<TemplateParam1, TemplateParam2> ReallyReallyLongFunctionName( const std::string &SomeParameter, const SomeType<string, SomeOtherTemplateParameter> &ReallyReallyLongParameterName, const SomeType<string, SomeOtherTemplateParameter> &AnotherLongParameterName) {} After: ReallyLongReturnType<TemplateParam1, TemplateParam2> ReallyReallyLongFunctionName( const std::string &SomeParameter, const SomeType<string, SomeOtherTemplateParameter> & ReallyReallyLongParameterName, const SomeType<string, SomeOtherTemplateParameter> & AnotherLongParameterName) {} llvm-svn: 175999
2013-02-25 02:54:32 +08:00
Line.MightBeFunctionDecl = true;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
break;
case tok::l_square:
if (!parseSquare())
return false;
break;
case tok::l_brace:
[clang-format] Support text proto messages Summary: This patch adds support for textual protocol buffer messages. Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek, mgorny Differential Revision: https://reviews.llvm.org/D34441 llvm-svn: 307029
2017-07-03 23:05:14 +08:00
if (Style.Language == FormatStyle::LK_TextProto) {
clang-format clang-format. llvm-svn: 313744
2017-09-20 17:51:03 +08:00
FormatToken *Previous = Tok->getPreviousNonComment();
[clang-format] Support text proto messages Summary: This patch adds support for textual protocol buffer messages. Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek, mgorny Differential Revision: https://reviews.llvm.org/D34441 llvm-svn: 307029
2017-07-03 23:05:14 +08:00
if (Previous && Previous->Type != TT_DictLiteral)
Previous->Type = TT_SelectorName;
}
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
if (!parseBrace())
return false;
break;
case tok::less:
clang-format: Fix corner case in template detection. Before: f(a.operator() < A > ()); After: f(a.operator()<A>()); llvm-svn: 259884
2016-02-05 22:17:16 +08:00
if (parseAngle()) {
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
Tok->Type = TT_TemplateOpener;
[clang-format] Adds space around angle brackets in text protos Summary: This patch adds spaces around angle brackets in text proto Google style. Previously these were detected as template openers and closers, which happened to have the expected effect. Now we detect them as scope openers and closers similarly to the way braces are handled in this context. Reviewers: djasper Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D42727 llvm-svn: 324337
2018-02-06 19:34:34 +08:00
// 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->Type = TT_DictLiteral;
[clang-format] Support text proto messages Summary: This patch adds support for textual protocol buffer messages. Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek, mgorny Differential Revision: https://reviews.llvm.org/D34441 llvm-svn: 307029
2017-07-03 23:05:14 +08:00
FormatToken *Previous = Tok->getPreviousNonComment();
if (Previous && Previous->Type != TT_DictLiteral)
Previous->Type = TT_SelectorName;
}
clang-format: Improve template parameter detection. Before: struct A < std::enable_if<sizeof(T2) <sizeof(int32)>::type>; After: struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>; llvm-svn: 225435
2015-01-08 16:48:21 +08:00
} else {
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
Tok->Type = TT_BinaryOperator;
clang-format: Prevent exponential runtime in token annotator. llvm-svn: 236577
2015-05-06 16:38:24 +08:00
NonTemplateLess.insert(Tok);
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
CurrentToken = Tok;
next();
}
break;
case tok::r_paren:
case tok::r_square:
return false;
case tok::r_brace:
Revert "[clang-format] Improve Incomplete detection for (text) protos" This reverts commit r330016. The incomplete detection has too many false positives, picking up typos for hard failures and refusing to format anything in that case. llvm-svn: 330569
2018-04-23 16:50:36 +08:00
// Lines can start with '}'.
if (Tok->Previous)
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return false;
break;
case tok::greater:
Revert "[clang-format] Improve Incomplete detection for (text) protos" This reverts commit r330016. The incomplete detection has too many false positives, picking up typos for hard failures and refusing to format anything in that case. llvm-svn: 330569
2018-04-23 16:50:36 +08:00
if (Style.Language != FormatStyle::LK_TextProto)
Tok->Type = TT_BinaryOperator;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
break;
case tok::kw_operator:
[clang-format] Format operator key in protos Summary: This fixes a glitch where ``operator: value`` in a text proto would mess up the underlying formatting since it gets parsed as a kw_operator instead of an identifier. Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D43830 llvm-svn: 326227
2018-02-28 03:07:47 +08:00
if (Style.Language == FormatStyle::LK_TextProto ||
Style.Language == FormatStyle::LK_Proto)
break;
clang-format: Fix segfault in overloaded operator parsing. Before, constructs like: using A::operator+; caused a segfault. This fixes llvm.org/PR17050. llvm-svn: 189749
2013-09-02 17:20:39 +08:00
while (CurrentToken &&
!CurrentToken->isOneOf(tok::l_paren, tok::semi, tok::r_paren)) {
Added AnnotatedToken::isOneOf + a few other refactorings Summary: <subj> Reviewers: djasper Reviewed By: djasper CC: cfe-commits, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D536 llvm-svn: 176951
2013-03-13 22:41:29 +08:00
if (CurrentToken->isOneOf(tok::star, tok::amp))
Fix formatting of overloaded operator definitions. Before: operatorvoid*(); operator vector< A< A>>(); After: operator void *(); operator vector<A<A> >(); llvm-svn: 174863
2013-02-11 16:01:18 +08:00
CurrentToken->Type = TT_PointerOrReference;
consumeToken();
clang-format: Support definitions/declarations of operator,. Before: bool operator, (); After: bool operator,(); llvm-svn: 257256
2016-01-09 23:56:40 +08:00
if (CurrentToken &&
[clang-format] Handle unary operator overload with arguments and specifiers Before: int operator++(int)noexcept; After: int operator++(int) noexcept; Patch by Igor Sugak. Thank you! llvm-svn: 317473
2017-11-06 20:11:51 +08:00
CurrentToken->Previous->isOneOf(TT_BinaryOperator, TT_UnaryOperator,
tok::comma))
clang-format: Fix corner case in overloaded operator definitions. Before: SomeLoooooooooooooooooooooooooogType operator> >(const SomeLooooooooooooooooooooooooogType &other); SomeLoooooooooooooooooooooooooogType // break operator>>(const SomeLooooooooooooooooooooooooogType &other); After: SomeLoooooooooooooooooooooooooogType operator>>(const SomeLooooooooooooooooooooooooogType &other); SomeLoooooooooooooooooooooooooogType // break operator>>(const SomeLooooooooooooooooooooooooogType &other); This fixes llvm.org/PR16328. llvm-svn: 189450
2013-08-28 15:27:35 +08:00
CurrentToken->Previous->Type = TT_OverloadedOperator;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
}
Fix bug when formatting overloaded operators. Before, the actual operator of an overloaded operator declaration was handled as a binary operator an thus, clang-format could not find valid formattings for many examples, e.g.: template <typename AAAAAAA, typename BBBBBBB> AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b); llvm-svn: 181585
2013-05-10 15:59:58 +08:00
if (CurrentToken) {
Fix formatting of overloaded operator definitions. Before: operatorvoid*(); operator vector< A< A>>(); After: operator void *(); operator vector<A<A> >(); llvm-svn: 174863
2013-02-11 16:01:18 +08:00
CurrentToken->Type = TT_OverloadedOperatorLParen;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (CurrentToken->Previous->is(TT_BinaryOperator))
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
CurrentToken->Previous->Type = TT_OverloadedOperator;
Fix bug when formatting overloaded operators. Before, the actual operator of an overloaded operator declaration was handled as a binary operator an thus, clang-format could not find valid formattings for many examples, e.g.: template <typename AAAAAAA, typename BBBBBBB> AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b); llvm-svn: 181585
2013-05-10 15:59:58 +08:00
}
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
break;
case tok::question:
clang-format: [JS] support optionality markers in JS types. Patch by Martin Probst. Thank you. llvm-svn: 234753
2015-04-13 23:01:40 +08:00
if (Style.Language == FormatStyle::LK_JavaScript && Tok->Next &&
clang-format: [JS] Ensure that formatting actually takes place in tests. And fix formatting issue discovered by that :-). llvm-svn: 239530
2015-06-11 21:29:20 +08:00
Tok->Next->isOneOf(tok::semi, tok::comma, tok::colon, tok::r_paren,
clang-format: [JS] support optionality markers in JS types. Patch by Martin Probst. Thank you. llvm-svn: 234753
2015-04-13 23:01:40 +08:00
tok::r_brace)) {
clang-format: [JS] support optional methods. Optional methods use ? tokens like this: interface X { y?(): z; } It seems easiest to detect and disambiguate these from ternary expressions by checking if the code is in a declaration context. Turns out that that didn't quite work properly for interfaces in Java and JS, and for JS file root contexts. Patch by Martin Probst, thank you. llvm-svn: 236488
2015-05-05 16:40:32 +08:00
// Question marks before semicolons, colons, etc. indicate optional
// types (fields, parameters), e.g.
// function(x?: string, y?) {...}
// class X { y?; }
clang-format: [JS] support optionality markers in JS types. Patch by Martin Probst. Thank you. llvm-svn: 234753
2015-04-13 23:01:40 +08:00
Tok->Type = TT_JsTypeOptionalQuestion;
break;
}
clang-format: [JS] support optional methods. Optional methods use ? tokens like this: interface X { y?(): z; } It seems easiest to detect and disambiguate these from ternary expressions by checking if the code is in a declaration context. Turns out that that didn't quite work properly for interfaces in Java and JS, and for JS file root contexts. Patch by Martin Probst, thank you. llvm-svn: 236488
2015-05-05 16:40:32 +08:00
// Declarations cannot be conditional expressions, this can only be part
// of a type declaration.
clang-format: [JS] Allow top-level conditionals again. I am not sure exactly which test breakage Martin was trying to fix in r273694. For now, fix the behavior for top-level conditionals, which (surprisingly) are actually used somewhat commonly. llvm-svn: 275183
2016-07-12 23:45:53 +08:00
if (Line.MustBeDeclaration && !Contexts.back().IsExpression &&
clang-format: [JS] support optional methods. Optional methods use ? tokens like this: interface X { y?(): z; } It seems easiest to detect and disambiguate these from ternary expressions by checking if the code is in a declaration context. Turns out that that didn't quite work properly for interfaces in Java and JS, and for JS file root contexts. Patch by Martin Probst, thank you. llvm-svn: 236488
2015-05-05 16:40:32 +08:00
Style.Language == FormatStyle::LK_JavaScript)
break;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
parseConditional();
break;
case tok::kw_template:
parseTemplateDeclaration();
break;
Improve formatting of for loops and multi-variable DeclStmts. This combines several related changes: a) Don't break before after the variable types in for loops with a single variable. b) Better indent DeclStmts defining multiple variables. Before: bool aaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa), bbbbbbbbbbbbbbbbbbbbbbbbb = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb); for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa; aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) { } After: bool aaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa), bbbbbbbbbbbbbbbbbbbbbbbbb = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb); for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa; aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) { } llvm-svn: 178641
2013-04-03 21:36:17 +08:00
case tok::comma:
clang-format: Fix incorrect multi-var declstmt detection. This is now obvious as the pointer alignment behavior was changed. Before (even with pointer alignment "Left"): MACRO Constructor(const int &i) : a(a), b(b) {} After: MACRO Constructor(const int& i) : a(a), b(b) {} llvm-svn: 235301
2015-04-20 20:54:29 +08:00
if (Contexts.back().InCtorInitializer)
Tok->Type = TT_CtorInitializerComma;
[clang-format] Add option to break before inheritance separation operator in class declaration. Differential Revision: https://reviews.llvm.org/D30487 llvm-svn: 297467
2017-03-10 23:10:37 +08:00
else if (Contexts.back().InInheritanceList)
Tok->Type = TT_InheritanceComma;
clang-format: Improve for-loop formatting. Before: for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator I = Container.begin(), E = Container.end(); I != E; ++I) After: for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator I = Container.begin(), E = Container.end(); I != E; ++I) This fixes llvm.org/PR23544. llvm-svn: 237688
2015-05-19 19:51:39 +08:00
else if (Contexts.back().FirstStartOfName &&
clang-format: NFC. Add a function to test whether an annotated line starts with a given sequence of tokens. Only the one-token version is used yet, but other usages are coming up momentarily. llvm-svn: 239892
2015-06-17 17:43:56 +08:00
(Contexts.size() == 1 || Line.startsWith(tok::kw_for))) {
Improve formatting of for loops and multi-variable DeclStmts. This combines several related changes: a) Don't break before after the variable types in for loops with a single variable. b) Better indent DeclStmts defining multiple variables. Before: bool aaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa), bbbbbbbbbbbbbbbbbbbbbbbbb = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb); for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa; aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) { } After: bool aaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa), bbbbbbbbbbbbbbbbbbbbbbbbb = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb); for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa; aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) { } llvm-svn: 178641
2013-04-03 21:36:17 +08:00
Contexts.back().FirstStartOfName->PartOfMultiVariableDeclStmt = true;
clang-format: Always align */& in multi-var DeclStmts. Seems like the most consistent thing to do and in multi-var DeclStmts, it is especially important to point out that the */& bind to the identifier. llvm-svn: 230903
2015-03-02 02:55:26 +08:00
Line.IsMultiVariableDeclStmt = true;
}
clang-format: Support configurable list of foreach-macros. This fixes llvm.org/PR17242. Patch by Brian Green, thank you! llvm-svn: 205307
2014-04-01 20:55:11 +08:00
if (Contexts.back().IsForEachMacro)
Contexts.back().IsExpression = true;
Improve formatting of for loops and multi-variable DeclStmts. This combines several related changes: a) Don't break before after the variable types in for loops with a single variable. b) Better indent DeclStmts defining multiple variables. Before: bool aaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa), bbbbbbbbbbbbbbbbbbbbbbbbb = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb); for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa; aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) { } After: bool aaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa), bbbbbbbbbbbbbbbbbbbbbbbbb = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb); for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa; aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) { } llvm-svn: 178641
2013-04-03 21:36:17 +08:00
break;
clang-format: don't break code using __has_include, PR31908 llvm-svn: 294772
2017-02-11 03:36:52 +08:00
case tok::identifier:
if (Tok->isOneOf(Keywords.kw___has_include,
Keywords.kw___has_include_next)) {
parseHasInclude();
}
break;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
default:
break;
}
return true;
}
void parseIncludeDirective() {
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
if (CurrentToken && CurrentToken->is(tok::less)) {
clang-format clang-format. llvm-svn: 313744
2017-09-20 17:51:03 +08:00
next();
while (CurrentToken) {
[clang-format] Handle trailing comment sections in import statement lines Summary: This patch updates the handling of multiline trailing comment sections in import statement lines to make it more consistent with the case in general. This includes updating the parsing logic to collect the trailing comment sections and the formatting logic to not insert escaped newlines at the end of comment lines in import statement lines. Specifically, before this patch this code: ``` #include <a> // line 1 // line 2 ``` will be turned into two unwrapped lines, whereas this code: ``` int i; // line 1 // line 2 ``` is turned into a single unwrapped line, enabling reflowing across comments. An example where the old behaviour is bad is when partially formatting the lines 3 to 4 of this code: ``` #include <a> // line 1 // line 2 int i; ``` which gets turned into: ``` #include <a> // line 1 // line 2 int i; ``` because the two comment lines were independent and the indent was copied. Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D33351 llvm-svn: 303415
2017-05-19 18:34:57 +08:00
// Mark tokens up to the trailing line comments as implicit string
// literals.
if (CurrentToken->isNot(tok::comment) &&
!CurrentToken->TokenText.startswith("//"))
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
CurrentToken->Type = TT_ImplicitStringLiteral;
next();
}
}
}
void parseWarningOrError() {
next();
// We still want to format the whitespace left of the first token of the
// warning or error.
next();
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
while (CurrentToken) {
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
CurrentToken->Type = TT_ImplicitStringLiteral;
next();
}
}
clang-format: Understand #pragma mark Before: #pragma mark Any non - hyphenated or hyphenated string(including parentheses). After: #pragma mark Any non-hyphenated or hyphenated string (including parentheses). llvm-svn: 198870
2014-01-09 21:56:49 +08:00
void parsePragma() {
next(); // Consume "pragma".
clang-format: Fix for #pragma option formatting. Adapted patch from Sergey Razmetov. Thank you. llvm-svn: 235492
2015-04-22 17:45:42 +08:00
if (CurrentToken &&
CurrentToken->isOneOf(Keywords.kw_mark, Keywords.kw_option)) {
bool IsMark = CurrentToken->is(Keywords.kw_mark);
clang-format: Understand #pragma mark Before: #pragma mark Any non - hyphenated or hyphenated string(including parentheses). After: #pragma mark Any non-hyphenated or hyphenated string (including parentheses). llvm-svn: 198870
2014-01-09 21:56:49 +08:00
next(); // Consume "mark".
next(); // Consume first token (so we fix leading whitespace).
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
while (CurrentToken) {
clang-format: Fix for #pragma option formatting. Adapted patch from Sergey Razmetov. Thank you. llvm-svn: 235492
2015-04-22 17:45:42 +08:00
if (IsMark || CurrentToken->Previous->is(TT_BinaryOperator))
CurrentToken->Type = TT_ImplicitStringLiteral;
clang-format: Understand #pragma mark Before: #pragma mark Any non - hyphenated or hyphenated string(including parentheses). After: #pragma mark Any non-hyphenated or hyphenated string (including parentheses). llvm-svn: 198870
2014-01-09 21:56:49 +08:00
next();
}
}
}
clang-format: don't break code using __has_include, PR31908 llvm-svn: 294772
2017-02-11 03:36:52 +08:00
void parseHasInclude() {
if (!CurrentToken || !CurrentToken->is(tok::l_paren))
return;
clang-format clang-format. llvm-svn: 313744
2017-09-20 17:51:03 +08:00
next(); // '('
clang-format: don't break code using __has_include, PR31908 llvm-svn: 294772
2017-02-11 03:36:52 +08:00
parseIncludeDirective();
clang-format clang-format. llvm-svn: 313744
2017-09-20 17:51:03 +08:00
next(); // ')'
clang-format: don't break code using __has_include, PR31908 llvm-svn: 294772
2017-02-11 03:36:52 +08:00
}
clang-format: [JS] Support Closure's module statements. These are like import statements and should not be line-wrapped. Minor restructuring of the handling of other import statements. llvm-svn: 222637
2014-11-24 00:46:28 +08:00
LineType parsePreprocessorDirective() {
clang-format: [JS] Support shebang lines on the very first line. Summary: Shebang lines (`#!/bin/blah`) can be used in JavaScript scripts to indicate they should be run using e.g. node. This change treats # lines on the first line as line comments. Reviewers: djasper Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D20632 llvm-svn: 271185
2016-05-29 22:41:36 +08:00
bool IsFirstToken = CurrentToken->IsFirst;
clang-format: [JS] Support Closure's module statements. These are like import statements and should not be line-wrapped. Minor restructuring of the handling of other import statements. llvm-svn: 222637
2014-11-24 00:46:28 +08:00
LineType Type = LT_PreprocessorDirective;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
next();
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
if (!CurrentToken)
clang-format: [JS] Support Closure's module statements. These are like import statements and should not be line-wrapped. Minor restructuring of the handling of other import statements. llvm-svn: 222637
2014-11-24 00:46:28 +08:00
return Type;
clang-format: [JS] Support shebang lines on the very first line. Summary: Shebang lines (`#!/bin/blah`) can be used in JavaScript scripts to indicate they should be run using e.g. node. This change treats # lines on the first line as line comments. Reviewers: djasper Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D20632 llvm-svn: 271185
2016-05-29 22:41:36 +08:00
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->Type = TT_ImplicitStringLiteral;
next();
}
return LT_ImportStatement;
}
Don't break string literals inside preprocessor directives. Summary: This way we avoid breaking code which uses unknown preprocessor directives with long string literals. The specific use case in http://llvm.org/PR17035 isn't very common, but it seems to be a good idea to avoid this kind of problem anyway. Reviewers: djasper Reviewed By: djasper CC: cfe-commits, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D1813 llvm-svn: 192507
2013-10-12 05:43:05 +08:00
if (CurrentToken->Tok.is(tok::numeric_constant)) {
CurrentToken->SpacesRequiredBefore = 1;
clang-format: [JS] Support Closure's module statements. These are like import statements and should not be line-wrapped. Minor restructuring of the handling of other import statements. llvm-svn: 222637
2014-11-24 00:46:28 +08:00
return Type;
Don't break string literals inside preprocessor directives. Summary: This way we avoid breaking code which uses unknown preprocessor directives with long string literals. The specific use case in http://llvm.org/PR17035 isn't very common, but it seems to be a good idea to avoid this kind of problem anyway. Reviewers: djasper Reviewed By: djasper CC: cfe-commits, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D1813 llvm-svn: 192507
2013-10-12 05:43:05 +08:00
}
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
// Hashes in the middle of a line can lead to any strange token
// sequence.
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
if (!CurrentToken->Tok.getIdentifierInfo())
clang-format: [JS] Support Closure's module statements. These are like import statements and should not be line-wrapped. Minor restructuring of the handling of other import statements. llvm-svn: 222637
2014-11-24 00:46:28 +08:00
return Type;
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
switch (CurrentToken->Tok.getIdentifierInfo()->getPPKeywordID()) {
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
case tok::pp_include:
clang-format: Support #include_next Before: #include_next < test.h > After: #include_next <test.h> This fixes llvm.org/PR23500 llvm-svn: 237686
2015-05-19 19:22:29 +08:00
case tok::pp_include_next:
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
case tok::pp_import:
clang-format: Understand #defines defining system includes. Before: #define MY_IMPORT < a / b > After: #define MY_IMPORT <a/b> llvm-svn: 215527
2014-08-13 16:29:18 +08:00
next();
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
parseIncludeDirective();
clang-format: [JS] Support Closure's module statements. These are like import statements and should not be line-wrapped. Minor restructuring of the handling of other import statements. llvm-svn: 222637
2014-11-24 00:46:28 +08:00
Type = LT_ImportStatement;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
break;
case tok::pp_error:
case tok::pp_warning:
parseWarningOrError();
break;
clang-format: Understand #pragma mark Before: #pragma mark Any non - hyphenated or hyphenated string(including parentheses). After: #pragma mark Any non-hyphenated or hyphenated string (including parentheses). llvm-svn: 198870
2014-01-09 21:56:49 +08:00
case tok::pp_pragma:
parsePragma();
break;
Fix formatting of complex #if expressions. Before: #if !defined(AAAAAAAAAAAAAAAA) && (defined CCCCCCCC || \ defined DDDDDDDD) && defined(BBBBBBBB) After: #if !defined(AAAAAAAAAAAAAAAA) && (defined CCCCCCCC || defined DDDDDDDD) && \ defined(BBBBBBBB) This fixes llvm.org/PR15828. llvm-svn: 180105
2013-04-23 21:54:04 +08:00
case tok::pp_if:
case tok::pp_elif:
clang-format: text following #if is likely an expression. Before: #if AAAA &&BBBB After: #if AAAA && BBBB llvm-svn: 199713
2014-01-21 16:56:09 +08:00
Contexts.back().IsExpression = true;
Fix formatting of complex #if expressions. Before: #if !defined(AAAAAAAAAAAAAAAA) && (defined CCCCCCCC || \ defined DDDDDDDD) && defined(BBBBBBBB) After: #if !defined(AAAAAAAAAAAAAAAA) && (defined CCCCCCCC || defined DDDDDDDD) && \ defined(BBBBBBBB) This fixes llvm.org/PR15828. llvm-svn: 180105
2013-04-23 21:54:04 +08:00
parseLine();
break;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
default:
break;
}
clang-format: don't break code using __has_include, PR31908 llvm-svn: 294772
2017-02-11 03:36:52 +08:00
while (CurrentToken) {
FormatToken *Tok = CurrentToken;
Fix formatting regression introduced by r174307. In preprocessor definitions, we would not parse all the tokens and thus not annotate them anymore. This led to a wrong formatting of comments in google style: #endif // HEADER_GUARD -- requires two spaces llvm-svn: 174361
2013-02-05 17:34:14 +08:00
next();
clang-format: Properly match parens of macro parameter lists. No tests yet, but this will be tested by the upcoming: https://reviews.llvm.org/D28462 llvm-svn: 300661
2017-04-19 14:06:38 +08:00
if (Tok->is(tok::l_paren))
parseParens();
else if (Tok->isOneOf(Keywords.kw___has_include,
clang-format clang-format. llvm-svn: 313744
2017-09-20 17:51:03 +08:00
Keywords.kw___has_include_next))
clang-format: don't break code using __has_include, PR31908 llvm-svn: 294772
2017-02-11 03:36:52 +08:00
parseHasInclude();
}
clang-format: [JS] Support Closure's module statements. These are like import statements and should not be line-wrapped. Minor restructuring of the handling of other import statements. llvm-svn: 222637
2014-11-24 00:46:28 +08:00
return Type;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
}
Formatter: Correctly format stars in `sizeof(int**)` and similar places. This redoes how '*' and '&' are classified as pointer / reference markers when followed by ')', '>', or ','. Previously, determineStarAmpUsage() marked a single '*' and '&' followed by ')', '>', or ',' as pointer or reference marker. Now, all '*'s and '&'s preceding ')', '>', or ',' are marked as pointer / reference markers. Fixes PR14884. Since only the last '*' in 'int ***' was marked as pointer before (the rest were unary operators, which don't reach spaceRequiredBetween()), spaceRequiredBetween() now had to be thought about handing multiple '*'s in sequence. Before: return sizeof(int * *); Type **A = static_cast<Type * *>(P); Now: return sizeof(int**); Type **A = static_cast<Type **>(P); While here, also make all methods of AnnotatingParser except parseLine() private. Review URL: http://llvm-reviews.chandlerc.com/D384 llvm-svn: 174975
2013-02-13 00:17:07 +08:00
public:
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
LineType parseLine() {
clang-format: Prevent exponential runtime in token annotator. llvm-svn: 236577
2015-05-06 16:38:24 +08:00
NonTemplateLess.clear();
clang-format: [Proto] Don't linewrap top-level options. They are very similar to import statements. llvm-svn: 235582
2015-04-23 17:54:10 +08:00
if (CurrentToken->is(tok::hash))
clang-format: [JS] Support Closure's module statements. These are like import statements and should not be line-wrapped. Minor restructuring of the handling of other import statements. llvm-svn: 222637
2014-11-24 00:46:28 +08:00
return parsePreprocessorDirective();
clang-format: text following #if is likely an expression. Before: #if AAAA &&BBBB After: #if AAAA && BBBB llvm-svn: 199713
2014-01-21 16:56:09 +08:00
clang-format: Don't break lines starting with "import <string-literal>" The author might be missing the "#" or these might be protocol buffer definitions. Either way, we should not break the line or the string. There don't seem to be other valid use cases. llvm-svn: 199501
2014-01-18 00:21:39 +08:00
// Directly allow to 'import <string-literal>' to support protocol buffer
Update link to protobuf llvm-svn: 318110
2017-11-14 07:27:55 +08:00
// definitions (github.com/google/protobuf) or missing "#" (either way we
clang-format: Don't break lines starting with "import <string-literal>" The author might be missing the "#" or these might be protocol buffer definitions. Either way, we should not break the line or the string. There don't seem to be other valid use cases. llvm-svn: 199501
2014-01-18 00:21:39 +08:00
// should not break the line).
IdentifierInfo *Info = CurrentToken->Tok.getIdentifierInfo();
clang-format: [Java] Don't line-wrap package declarations. This fixes llvm.org/PR21677. llvm-svn: 222843
2014-11-27 02:03:42 +08:00
if ((Style.Language == FormatStyle::LK_Java &&
CurrentToken->is(Keywords.kw_package)) ||
(Info && Info->getPPKeywordID() == tok::pp_import &&
clang-format: More restrictively classify import declarations. Before: import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaa); After: import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaa); llvm-svn: 223345
2014-12-04 16:57:27 +08:00
CurrentToken->Next &&
clang-format: [Java] Understand "import static". llvm-svn: 225965
2015-01-14 18:02:49 +08:00
CurrentToken->Next->isOneOf(tok::string_literal, tok::identifier,
tok::kw_static))) {
clang-format: Understand #defines defining system includes. Before: #define MY_IMPORT < a / b > After: #define MY_IMPORT <a/b> llvm-svn: 215527
2014-08-13 16:29:18 +08:00
next();
clang-format: Don't break lines starting with "import <string-literal>" The author might be missing the "#" or these might be protocol buffer definitions. Either way, we should not break the line or the string. There don't seem to be other valid use cases. llvm-svn: 199501
2014-01-18 00:21:39 +08:00
parseIncludeDirective();
clang-format: [JS] Support Closure's module statements. These are like import statements and should not be line-wrapped. Minor restructuring of the handling of other import statements. llvm-svn: 222637
2014-11-24 00:46:28 +08:00
return LT_ImportStatement;
clang-format: Understand #defines defining system includes. Before: #define MY_IMPORT < a / b > After: #define MY_IMPORT <a/b> llvm-svn: 215527
2014-08-13 16:29:18 +08:00
}
// 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();
clang-format: [JS] Support Closure's module statements. These are like import statements and should not be line-wrapped. Minor restructuring of the handling of other import statements. llvm-svn: 222637
2014-11-24 00:46:28 +08:00
return LT_ImportStatement;
clang-format: Understand #defines defining system includes. Before: #define MY_IMPORT < a / b > After: #define MY_IMPORT <a/b> llvm-svn: 215527
2014-08-13 16:29:18 +08:00
}
clang-format: Don't break lines starting with "import <string-literal>" The author might be missing the "#" or these might be protocol buffer definitions. Either way, we should not break the line or the string. There don't seem to be other valid use cases. llvm-svn: 199501
2014-01-18 00:21:39 +08:00
clang-format: [Proto] Don't linewrap top-level options. They are very similar to import statements. llvm-svn: 235582
2015-04-23 17:54:10 +08:00
// In .proto files, top-level options are very similar to import statements
// and should not be line-wrapped.
if (Style.Language == FormatStyle::LK_Proto && Line.Level == 0 &&
CurrentToken->is(Keywords.kw_option)) {
next();
if (CurrentToken && CurrentToken->is(tok::identifier))
return LT_ImportStatement;
}
clang-format: [JS] Introduce JavaScriptWrapImports option. Summary: When turned on, clang-format wraps JavaScript imports (and importing exports), instead of forcing the entire import statement onto one line. Reviewers: djasper Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D21273 llvm-svn: 272558
2016-06-14 00:39:50 +08:00
bool KeywordVirtualFound = false;
bool ImportStatement = false;
clang-format: [JS] do not wrap ES6 imports/exports. "import ... from '...';" and "export ... from '...';" should be treated the same as goog.require/provide/module/forwardDeclare calls. Patch by Martin Probst. llvm-svn: 264055
2016-03-22 22:32:20 +08:00
// import {...} from '...';
if (Style.Language == FormatStyle::LK_JavaScript &&
CurrentToken->is(Keywords.kw_import))
clang-format: [JS] Introduce JavaScriptWrapImports option. Summary: When turned on, clang-format wraps JavaScript imports (and importing exports), instead of forcing the entire import statement onto one line. Reviewers: djasper Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D21273 llvm-svn: 272558
2016-06-14 00:39:50 +08:00
ImportStatement = true;
clang-format: [JS] do not wrap ES6 imports/exports. "import ... from '...';" and "export ... from '...';" should be treated the same as goog.require/provide/module/forwardDeclare calls. Patch by Martin Probst. llvm-svn: 264055
2016-03-22 22:32:20 +08:00
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
while (CurrentToken) {
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
if (CurrentToken->is(tok::kw_virtual))
KeywordVirtualFound = true;
clang-format: [JS] do not wrap ES6 imports/exports. "import ... from '...';" and "export ... from '...';" should be treated the same as goog.require/provide/module/forwardDeclare calls. Patch by Martin Probst. llvm-svn: 264055
2016-03-22 22:32:20 +08:00
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;
}
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
if (!consumeToken())
return LT_Invalid;
}
if (KeywordVirtualFound)
return LT_VirtualFunctionDecl;
clang-format: [JS] Support Closure's module statements. These are like import statements and should not be line-wrapped. Minor restructuring of the handling of other import statements. llvm-svn: 222637
2014-11-24 00:46:28 +08:00
if (ImportStatement)
return LT_ImportStatement;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
clang-format: NFC. Add a function to test whether an annotated line starts with a given sequence of tokens. Only the one-token version is used yet, but other usages are coming up momentarily. llvm-svn: 239892
2015-06-17 17:43:56 +08:00
if (Line.startsWith(TT_ObjCMethodSpecifier)) {
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
if (Contexts.back().FirstObjCSelectorName)
Handle nested ObjC calls. Properly handle annotation contexts while calculating extra information for each token. This enable nested ObjC calls and thus solves (most of) llvm.org/PR15164. E.g., we can now format: [contentsContainer replaceSubview:[subviews objectAtIndex:0] with:contentsNativeView]; Also fix a problem with the formatting of types in casts as this was trivial now. llvm-svn: 174498
2013-02-06 18:05:46 +08:00
Contexts.back().FirstObjCSelectorName->LongestObjCSelectorName =
Contexts.back().LongestObjCSelectorName;
Initial support for formatting ObjC method declarations/calls. We can now format stuff like: - (void)doSomethingWith:(GTMFoo *)theFoo rect:(NSRect)theRect interval:(float)theInterval { [myObject doFooWith:arg1 // name:arg2 error:arg3]; } This seems to fix everything mentioned in llvm.org/PR14939. llvm-svn: 174364
2013-02-05 18:07:47 +08:00
return LT_ObjCMethodDecl;
}
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return LT_Other;
}
Formatter: Correctly format stars in `sizeof(int**)` and similar places. This redoes how '*' and '&' are classified as pointer / reference markers when followed by ')', '>', or ','. Previously, determineStarAmpUsage() marked a single '*' and '&' followed by ')', '>', or ',' as pointer or reference marker. Now, all '*'s and '&'s preceding ')', '>', or ',' are marked as pointer / reference markers. Fixes PR14884. Since only the last '*' in 'int ***' was marked as pointer before (the rest were unary operators, which don't reach spaceRequiredBetween()), spaceRequiredBetween() now had to be thought about handing multiple '*'s in sequence. Before: return sizeof(int * *); Type **A = static_cast<Type * *>(P); Now: return sizeof(int**); Type **A = static_cast<Type **>(P); While here, also make all methods of AnnotatingParser except parseLine() private. Review URL: http://llvm-reviews.chandlerc.com/D384 llvm-svn: 174975
2013-02-13 00:17:07 +08:00
private:
clang-format: [JS] do not wrap ES6 imports/exports. "import ... from '...';" and "export ... from '...';" should be treated the same as goog.require/provide/module/forwardDeclare calls. Patch by Martin Probst. llvm-svn: 264055
2016-03-22 22:32:20 +08:00
bool isClosureImportStatement(const FormatToken &Tok) {
clang-format: [JS] Support Closure's module statements. These are like import statements and should not be line-wrapped. Minor restructuring of the handling of other import statements. llvm-svn: 222637
2014-11-24 00:46:28 +08:00
// FIXME: Closure-library specific stuff should not be hard-coded but be
// configurable.
clang-format: [JS] do not wrap ES6 imports/exports. "import ... from '...';" and "export ... from '...';" should be treated the same as goog.require/provide/module/forwardDeclare calls. Patch by Martin Probst. llvm-svn: 264055
2016-03-22 22:32:20 +08:00
return Tok.TokenText == "goog" && Tok.Next && Tok.Next->is(tok::period) &&
clang-format clang-format. llvm-svn: 313744
2017-09-20 17:51:03 +08:00
Tok.Next->Next &&
(Tok.Next->Next->TokenText == "module" ||
Tok.Next->Next->TokenText == "provide" ||
Tok.Next->Next->TokenText == "require" ||
Tok.Next->Next->TokenText == "forwardDeclare") &&
clang-format: [JS] Make Closure module detection more narrow. Before: var MyLongClassName = goog.module.get('my.long.module.name.followedBy.MyLongClassName'); After: var MyLongClassName = goog.module.get('my.long.module.name.followedBy.MyLongClassName'); llvm-svn: 222888
2014-11-27 22:46:03 +08:00
Tok.Next->Next->Next && Tok.Next->Next->Next->is(tok::l_paren);
clang-format: [JS] Support Closure's module statements. These are like import statements and should not be line-wrapped. Minor restructuring of the handling of other import statements. llvm-svn: 222637
2014-11-24 00:46:28 +08:00
}
Fix crasher bug. Due to not resetting the fake rparen data on the token when iterating over annotated lines, we would pop the last element of the paren stack. This patch fixes the underlying root cause, and makes the code more robust against similar problems in the future: - reset the first token when iterating on the same annotated lines due to preprocessor branches - never pop the last element from the paren stack, so we do not crash, but rather incorrectly format - add assert()s so we can figure out if our assumptions are violated llvm-svn: 204140
2014-03-18 19:22:45 +08:00
void resetTokenMetadata(FormatToken *Token) {
clang-format: Fix bug introduced by r208392. Also run clang-format over clang-format's files. llvm-svn: 208409
2014-05-09 21:11:16 +08:00
if (!Token)
return;
Fix crasher bug. Due to not resetting the fake rparen data on the token when iterating over annotated lines, we would pop the last element of the paren stack. This patch fixes the underlying root cause, and makes the code more robust against similar problems in the future: - reset the first token when iterating on the same annotated lines due to preprocessor branches - never pop the last element from the paren stack, so we do not crash, but rather incorrectly format - add assert()s so we can figure out if our assumptions are violated llvm-svn: 204140
2014-03-18 19:22:45 +08:00
// Reset token type in case we have already looked at it and then
// recovered from an error (e.g. failure to find the matching >).
clang-format: NFC: Delete FormatToken::IsForEachMacro. Use a TokenType instead. llvm-svn: 236415
2015-05-04 17:22:29 +08:00
if (!CurrentToken->isOneOf(TT_LambdaLSquare, TT_ForEachMacro,
TT_FunctionLBrace, TT_ImplicitStringLiteral,
clang-format: More eagerly wrap trailing return types. Before: template <typename T> auto aaaaaaaaaaaaaaaaaaaaaa(T t) -> decltype(eaaaaaaaaaaaaaaa<T>(t.a) .aaaaaaaa()); After: template <typename T> auto aaaaaaaaaaaaaaaaaaaaaa(T t) -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa()); Also add a test case for a difficult template parsing case I stumbled accross. Needs fixing. llvm-svn: 239149
2015-06-05 21:18:09 +08:00
TT_InlineASMBrace, TT_JsFatArrow, TT_LambdaArrow,
clang-format: [JS] Fix formatting of generator functions. Before: var x = { a: function* () { // } } After: var x = { a: function*() { // } } llvm-svn: 285670
2016-11-01 14:22:59 +08:00
TT_OverloadedOperator, TT_RegexLiteral,
[clang-format] Handle NSString literals by merging tokens. Summary: This fixes a few outstanding bugs: * incorrect breaking of NSString literals containing double-width characters; * inconsistent formatting of ObjC dictionary literals containing NSString literals; * AlwaysBreakBeforeMultilineStrings ignoring implicitly-concatenated NSString literals. Reviewers: djasper Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D31706 llvm-svn: 299927
2017-04-11 17:55:00 +08:00
TT_TemplateString, TT_ObjCStringLiteral))
Fix crasher bug. Due to not resetting the fake rparen data on the token when iterating over annotated lines, we would pop the last element of the paren stack. This patch fixes the underlying root cause, and makes the code more robust against similar problems in the future: - reset the first token when iterating on the same annotated lines due to preprocessor branches - never pop the last element from the paren stack, so we do not crash, but rather incorrectly format - add assert()s so we can figure out if our assumptions are violated llvm-svn: 204140
2014-03-18 19:22:45 +08:00
CurrentToken->Type = TT_Unknown;
Remove uses of the redundant ".reset(nullptr)" of unique_ptr, in favor of ".reset()" It's also possible to just write "= nullptr", but there's some question of whether that's as readable, so I leave it up to authors to pick which they prefer for now. If we want to discuss standardizing on one or the other, we can do that at some point in the future. llvm-svn: 213439
2014-07-19 09:06:45 +08:00
CurrentToken->Role.reset();
clang-format: Fix bad memory access. llvm-svn: 226680
2015-01-22 02:04:02 +08:00
CurrentToken->MatchingParen = nullptr;
Fix crasher bug. Due to not resetting the fake rparen data on the token when iterating over annotated lines, we would pop the last element of the paren stack. This patch fixes the underlying root cause, and makes the code more robust against similar problems in the future: - reset the first token when iterating on the same annotated lines due to preprocessor branches - never pop the last element from the paren stack, so we do not crash, but rather incorrectly format - add assert()s so we can figure out if our assumptions are violated llvm-svn: 204140
2014-03-18 19:22:45 +08:00
CurrentToken->FakeLParens.clear();
CurrentToken->FakeRParens = 0;
}
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
void next() {
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
if (CurrentToken) {
clang-format: Be more conservative about braced list column layout. Specifically disable it for nested braced lists as it commonly can look really weird. Eventually, we'll want to become smarter and format some of the nested lists better. Before: SomeStruct my_struct_array = { { aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaa, aaa }, { aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa }, { aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa }, }; After: SomeStruct my_struct_array = { { aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaa, aaaaaaa, aaa }, { aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa }, { aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa }, }; llvm-svn: 196783
2013-12-09 22:40:19 +08:00
CurrentToken->NestingLevel = Contexts.size() - 1;
clang-format: Support breaking arguments of function type typedefs. Before: typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)( const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa); After: typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)( const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa); llvm-svn: 215631
2014-08-14 18:52:56 +08:00
CurrentToken->BindingStrength = Contexts.back().BindingStrength;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
modifyContext(*CurrentToken);
clang-format: Support breaking arguments of function type typedefs. Before: typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)( const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa); After: typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)( const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa); llvm-svn: 215631
2014-08-14 18:52:56 +08:00
determineTokenType(*CurrentToken);
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
CurrentToken = CurrentToken->Next;
clang-format: [JS] Initial support for regex literals. llvm-svn: 208281
2014-05-08 15:01:45 +08:00
}
Correctly determine */& usage in more cases. This fixes llvm.org/PR15248. Before: Test::Test(int b) : a(b *b) {} for (int i = 0; i < a *a; ++i) {} After: Test::Test(int b) : a(b * b) {} for (int i = 0; i < a * a; ++i) {} llvm-svn: 175439
2013-02-18 20:44:35 +08:00
Fix crasher bug. Due to not resetting the fake rparen data on the token when iterating over annotated lines, we would pop the last element of the paren stack. This patch fixes the underlying root cause, and makes the code more robust against similar problems in the future: - reset the first token when iterating on the same annotated lines due to preprocessor branches - never pop the last element from the paren stack, so we do not crash, but rather incorrectly format - add assert()s so we can figure out if our assumptions are violated llvm-svn: 204140
2014-03-18 19:22:45 +08:00
resetTokenMetadata(CurrentToken);
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
}
Remove \brief commands from doxygen comments. This is similar to the LLVM change https://reviews.llvm.org/D46290. We've been running doxygen with the autobrief option for a couple of years now. This makes the \brief markers into our comments redundant. Since they are a visual distraction and we don't want to encourage more \brief markers in new code either, this patch removes them all. Patch produced by for i in $(git grep -l '\@brief'); do perl -pi -e 's/\@brief //g' $i & done for i in $(git grep -l '\\brief'); do perl -pi -e 's/\\brief //g' $i & done Differential Revision: https://reviews.llvm.org/D46320 llvm-svn: 331834
2018-05-09 09:00:01 +08:00
/// A struct to hold information valid in a specific context, e.g.
Handle nested ObjC calls. Properly handle annotation contexts while calculating extra information for each token. This enable nested ObjC calls and thus solves (most of) llvm.org/PR15164. E.g., we can now format: [contentsContainer replaceSubview:[subviews objectAtIndex:0] with:contentsNativeView]; Also fix a problem with the formatting of types in casts as this was trivial now. llvm-svn: 174498
2013-02-06 18:05:46 +08:00
/// a pair of parenthesis.
struct Context {
Basic support for formatting asm() statments. llvm-svn: 177073
2013-03-14 21:45:21 +08:00
Context(tok::TokenKind ContextKind, unsigned BindingStrength,
bool IsExpression)
: ContextKind(ContextKind), BindingStrength(BindingStrength),
clang-format: Determine "in" as a keyword in ObjC for loops more precisely Before: for (int i = 0; i < in [a]; ++i) .. After: for (int i = 0; i < in[a]; ++i) .. Also do some related cleanups. llvm-svn: 234980
2015-04-15 15:26:18 +08:00
IsExpression(IsExpression) {}
Basic support for formatting asm() statments. llvm-svn: 177073
2013-03-14 21:45:21 +08:00
tok::TokenKind ContextKind;
Handle nested ObjC calls. Properly handle annotation contexts while calculating extra information for each token. This enable nested ObjC calls and thus solves (most of) llvm.org/PR15164. E.g., we can now format: [contentsContainer replaceSubview:[subviews objectAtIndex:0] with:contentsNativeView]; Also fix a problem with the formatting of types in casts as this was trivial now. llvm-svn: 174498
2013-02-06 18:05:46 +08:00
unsigned BindingStrength;
bool IsExpression;
clang-format: Determine "in" as a keyword in ObjC for loops more precisely Before: for (int i = 0; i < in [a]; ++i) .. After: for (int i = 0; i < in[a]; ++i) .. Also do some related cleanups. llvm-svn: 234980
2015-04-15 15:26:18 +08:00
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;
[clang-format] Add option to break before inheritance separation operator in class declaration. Differential Revision: https://reviews.llvm.org/D30487 llvm-svn: 297467
2017-03-10 23:10:37 +08:00
bool InInheritanceList = false;
clang-format: Determine "in" as a keyword in ObjC for loops more precisely Before: for (int i = 0; i < in [a]; ++i) .. After: for (int i = 0; i < in[a]; ++i) .. Also do some related cleanups. llvm-svn: 234980
2015-04-15 15:26:18 +08:00
bool CaretFound = false;
bool IsForEachMacro = false;
[clang-format] Don't detect C++11 attribute specifiers as ObjC Summary: Previously, clang-format would detect C++11 and C++17 attribute specifiers like the following as Objective-C method invocations: [[noreturn]]; [[clang::fallthrough]]; [[noreturn, deprecated("so sorry")]]; [[using gsl: suppress("type")]]; To fix this, I ported part of the logic from tools/clang/lib/Parse/ParseTentative.cpp into TokenAnnotator.cpp so we can explicitly parse and identify C++11 attribute specifiers. This allows the guessLanguage() and getStyle() APIs to correctly guess files containing the C++11 attribute specifiers as C++, not Objective-C. Test Plan: New tests added. Ran tests with: make -j12 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: krasimir, jolesiak, djasper Reviewed By: djasper Subscribers: aaron.ballman, cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D43902 llvm-svn: 327284
2018-03-12 23:42:38 +08:00
bool InCpp11AttributeSpecifier = false;
Handle nested ObjC calls. Properly handle annotation contexts while calculating extra information for each token. This enable nested ObjC calls and thus solves (most of) llvm.org/PR15164. E.g., we can now format: [contentsContainer replaceSubview:[subviews objectAtIndex:0] with:contentsNativeView]; Also fix a problem with the formatting of types in casts as this was trivial now. llvm-svn: 174498
2013-02-06 18:05:46 +08:00
};
Remove \brief commands from doxygen comments. This is similar to the LLVM change https://reviews.llvm.org/D46290. We've been running doxygen with the autobrief option for a couple of years now. This makes the \brief markers into our comments redundant. Since they are a visual distraction and we don't want to encourage more \brief markers in new code either, this patch removes them all. Patch produced by for i in $(git grep -l '\@brief'); do perl -pi -e 's/\@brief //g' $i & done for i in $(git grep -l '\\brief'); do perl -pi -e 's/\\brief //g' $i & done Differential Revision: https://reviews.llvm.org/D46320 llvm-svn: 331834
2018-05-09 09:00:01 +08:00
/// Puts a new \c Context onto the stack \c Contexts for the lifetime
Handle nested ObjC calls. Properly handle annotation contexts while calculating extra information for each token. This enable nested ObjC calls and thus solves (most of) llvm.org/PR15164. E.g., we can now format: [contentsContainer replaceSubview:[subviews objectAtIndex:0] with:contentsNativeView]; Also fix a problem with the formatting of types in casts as this was trivial now. llvm-svn: 174498
2013-02-06 18:05:46 +08:00
/// of each instance.
struct ScopedContextCreator {
AnnotatingParser &P;
Basic support for formatting asm() statments. llvm-svn: 177073
2013-03-14 21:45:21 +08:00
ScopedContextCreator(AnnotatingParser &P, tok::TokenKind ContextKind,
unsigned Increase)
: P(P) {
Reformat clang-format's source files after r185822 and others. llvm-svn: 185823
2013-07-08 22:34:09 +08:00
P.Contexts.push_back(Context(ContextKind,
P.Contexts.back().BindingStrength + Increase,
P.Contexts.back().IsExpression));
Handle nested ObjC calls. Properly handle annotation contexts while calculating extra information for each token. This enable nested ObjC calls and thus solves (most of) llvm.org/PR15164. E.g., we can now format: [contentsContainer replaceSubview:[subviews objectAtIndex:0] with:contentsNativeView]; Also fix a problem with the formatting of types in casts as this was trivial now. llvm-svn: 174498
2013-02-06 18:05:46 +08:00
}
~ScopedContextCreator() { P.Contexts.pop_back(); }
};
Restructuring of token annotation for formatting. This combines several changes: * Calculation token type (e.g. for * and &) in the AnnotatingParser. * Calculate the scope binding strength in the AnnotatingParser. * Let <> and [] scopes bind stronger than () and {} scopes. * Add minimal debugging output. llvm-svn: 174307
2013-02-04 15:21:18 +08:00
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
void modifyContext(const FormatToken &Current) {
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
if (Current.getPrecedence() == prec::Assignment &&
clang-format: Fix incorrect pointer detection. Before: return * this += 1; After: return *this += 1; llvm-svn: 256342
2015-12-24 02:01:29 +08:00
!Line.First->isOneOf(tok::kw_template, tok::kw_using, tok::kw_return) &&
clang-format: [JS] recognize exported type definitions. Summary: Support "export type T = {...};", in addition to just "type T = {...};". Reviewers: klimek Differential Revision: https://reviews.llvm.org/D33980 llvm-svn: 304904
2017-06-07 20:53:22 +08:00
// Type aliases use `type X = ...;` in TypeScript and can be exported
// using `export type ...`.
clang-format: [JS] recognize more type locations. Summary: Includes parenthesized type expressions and type aliases. Reviewers: djasper Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D21597 llvm-svn: 273603
2016-06-24 03:52:32 +08:00
!(Style.Language == FormatStyle::LK_JavaScript &&
clang-format: [JS] recognize exported type definitions. Summary: Support "export type T = {...};", in addition to just "type T = {...};". Reviewers: klimek Differential Revision: https://reviews.llvm.org/D33980 llvm-svn: 304904
2017-06-07 20:53:22 +08:00
(Line.startsWith(Keywords.kw_type, tok::identifier) ||
Line.startsWith(tok::kw_export, Keywords.kw_type,
tok::identifier))) &&
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
(!Current.Previous || Current.Previous->isNot(tok::kw_operator))) {
Handle nested ObjC calls. Properly handle annotation contexts while calculating extra information for each token. This enable nested ObjC calls and thus solves (most of) llvm.org/PR15164. E.g., we can now format: [contentsContainer replaceSubview:[subviews objectAtIndex:0] with:contentsNativeView]; Also fix a problem with the formatting of types in casts as this was trivial now. llvm-svn: 174498
2013-02-06 18:05:46 +08:00
Contexts.back().IsExpression = true;
clang-format: NFC. Add a function to test whether an annotated line starts with a given sequence of tokens. Only the one-token version is used yet, but other usages are coming up momentarily. llvm-svn: 239892
2015-06-17 17:43:56 +08:00
if (!Line.startsWith(TT_UnaryOperator)) {
clang-format: Fix incorrect classification of "*". Before: *a = b *c; After: *a = b * c; llvm-svn: 226923
2015-01-24 03:04:49 +08:00
for (FormatToken *Previous = Current.Previous;
clang-format: Fix unary operator detection in for loops. Before: for (;; * a = b) {} After: for (;; *a = b) {} llvm-svn: 242849
2015-07-22 06:51:00 +08:00
Previous && Previous->Previous &&
!Previous->Previous->isOneOf(tok::comma, tok::semi);
clang-format: Fix incorrect classification of "*". Before: *a = b *c; After: *a = b * c; llvm-svn: 226923
2015-01-24 03:04:49 +08:00
Previous = Previous->Previous) {
if (Previous->isOneOf(tok::r_square, tok::r_paren)) {
Previous = Previous->MatchingParen;
if (!Previous)
break;
}
clang-format: Fix incorrect && recognition. Before: if (a &&(b = c)) .. After: if (a && (b = c)) .. llvm-svn: 231920
2015-03-11 20:59:49 +08:00
if (Previous->opensScope())
break;
clang-format: Fix incorrect classification of "*". Before: *a = b *c; After: *a = b * c; llvm-svn: 226923
2015-01-24 03:04:49 +08:00
if (Previous->isOneOf(TT_BinaryOperator, TT_UnaryOperator) &&
clang-format: Fix spacing for function with ref-qualification .. .. when using SpacesInCStyleCastParentheses != SpacesInParentheses. Before: FormatStyle Spaces = getLLVMStyle(); Deleted &operator=(const Deleted &)& = default; Spaces.SpacesInParentheses = true; Deleted(const Deleted &)& = default; Spaces.SpacesInCStyleCastParentheses = true; Spaces.SpacesInParentheses= false; Deleted( const Deleted & )& = default; After: FormatStyle Spaces = getLLVMStyle(); Deleted &operator=(const Deleted &)& = default;; Spaces.SpacesInParentheses= true; Deleted( const Deleted & )& = default; Spaces.SpacesInCStyleCastParentheses = true; Spaces.SpacesInParentheses= false; Deleted(const Deleted &)& = default; Patch by Jean-Philippe Dufraigne. Thank you! llvm-svn: 230473
2015-02-25 18:30:06 +08:00
Previous->isOneOf(tok::star, tok::amp, tok::ampamp) &&
Previous->Previous && Previous->Previous->isNot(tok::equal))
clang-format: Fix incorrect classification of "*". Before: *a = b *c; After: *a = b * c; llvm-svn: 226923
2015-01-24 03:04:49 +08:00
Previous->Type = TT_PointerOrReference;
Fix crasher bug in clang-format. llvm-svn: 215549
2014-08-13 22:00:41 +08:00
}
Restructuring of token annotation for formatting. This combines several changes: * Calculation token type (e.g. for * and &) in the AnnotatingParser. * Calculate the scope binding strength in the AnnotatingParser. * Let <> and [] scopes bind stronger than () and {} scopes. * Add minimal debugging output. llvm-svn: 174307
2013-02-04 15:21:18 +08:00
}
clang-format: Improve *-detection. Before: S << a *(10); After: S << a * (10); This fixes llvm.org/PR16500. llvm-svn: 237690
2015-05-19 20:29:27 +08:00
} else if (Current.is(tok::lessless) &&
(!Current.Previous || !Current.Previous->is(tok::kw_operator))) {
Contexts.back().IsExpression = true;
clang-format: Fix formatting of function type parameters. Before: void f() { typedef void (*f)(int * a); } After: void f() { typedef void (*f)(int *a); } llvm-svn: 197369
2013-12-16 16:36:18 +08:00
} else if (Current.isOneOf(tok::kw_return, tok::kw_throw)) {
Handle nested ObjC calls. Properly handle annotation contexts while calculating extra information for each token. This enable nested ObjC calls and thus solves (most of) llvm.org/PR15164. E.g., we can now format: [contentsContainer replaceSubview:[subviews objectAtIndex:0] with:contentsNativeView]; Also fix a problem with the formatting of types in casts as this was trivial now. llvm-svn: 174498
2013-02-06 18:05:46 +08:00
Contexts.back().IsExpression = true;
clang-format: Understand more lambda return types. Before: auto a = [&b, c ](D * d) -> D * {} After: auto a = [&b, c](D* d) -> D* {} llvm-svn: 222534
2014-11-21 22:08:38 +08:00
} else if (Current.is(TT_TrailingReturnArrow)) {
Contexts.back().IsExpression = false;
clang-format: In Java, `assert` is followed by an expression. Before: assert a&& b; Now: assert a && b; llvm-svn: 247750
2015-09-16 07:48:17 +08:00
} else if (Current.is(TT_LambdaArrow) || Current.is(Keywords.kw_assert)) {
clang-format: More eagerly wrap trailing return types. Before: template <typename T> auto aaaaaaaaaaaaaaaaaaaaaa(T t) -> decltype(eaaaaaaaaaaaaaaa<T>(t.a) .aaaaaaaa()); After: template <typename T> auto aaaaaaaaaaaaaaaaaaaaaa(T t) -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa()); Also add a test case for a difficult template parsing case I stumbled accross. Needs fixing. llvm-svn: 239149
2015-06-05 21:18:09 +08:00
Contexts.back().IsExpression = Style.Language == FormatStyle::LK_Java;
Make clang-format cleaner remove redundant commas in list and redundant colon in constructor initializer. Summary: Make clang-format cleaner remove redundant commas/colons in constructor initializer list. Reviewers: klimek, djasper Subscribers: cfe-commits, klimek Differential Revision: http://reviews.llvm.org/D19804 llvm-svn: 269888
2016-05-18 16:02:56 +08:00
} else if (Current.Previous &&
Current.Previous->is(TT_CtorInitializerColon)) {
Contexts.back().IsExpression = true;
Contexts.back().InCtorInitializer = true;
clang-format clang-format. llvm-svn: 313744
2017-09-20 17:51:03 +08:00
} else if (Current.Previous && Current.Previous->is(TT_InheritanceColon)) {
[clang-format] Add option to break before inheritance separation operator in class declaration. Differential Revision: https://reviews.llvm.org/D30487 llvm-svn: 297467
2017-03-10 23:10:37 +08:00
Contexts.back().InInheritanceList = true;
Added AnnotatedToken::isOneOf + a few other refactorings Summary: <subj> Reviewers: djasper Reviewed By: djasper CC: cfe-commits, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D536 llvm-svn: 176951
2013-03-13 22:41:29 +08:00
} else if (Current.isOneOf(tok::r_paren, tok::greater, tok::comma)) {
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
for (FormatToken *Previous = Current.Previous;
Added AnnotatedToken::isOneOf + a few other refactorings Summary: <subj> Reviewers: djasper Reviewed By: djasper CC: cfe-commits, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D536 llvm-svn: 176951
2013-03-13 22:41:29 +08:00
Previous && Previous->isOneOf(tok::star, tok::amp);
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
Previous = Previous->Previous)
Formatter: Correctly format stars in `sizeof(int**)` and similar places. This redoes how '*' and '&' are classified as pointer / reference markers when followed by ')', '>', or ','. Previously, determineStarAmpUsage() marked a single '*' and '&' followed by ')', '>', or ',' as pointer or reference marker. Now, all '*'s and '&'s preceding ')', '>', or ',' are marked as pointer / reference markers. Fixes PR14884. Since only the last '*' in 'int ***' was marked as pointer before (the rest were unary operators, which don't reach spaceRequiredBetween()), spaceRequiredBetween() now had to be thought about handing multiple '*'s in sequence. Before: return sizeof(int * *); Type **A = static_cast<Type * *>(P); Now: return sizeof(int**); Type **A = static_cast<Type **>(P); While here, also make all methods of AnnotatingParser except parseLine() private. Review URL: http://llvm-reviews.chandlerc.com/D384 llvm-svn: 174975
2013-02-13 00:17:07 +08:00
Previous->Type = TT_PointerOrReference;
clang-format: Fix incorrect pointer detection in lambdas in constructor initializers. Before: Constructor() : member([](A *a, B * b) {}) {} After: Constructor() : member([](A *a, B *b) {}) {} llvm-svn: 259353
2016-02-01 19:21:07 +08:00
if (Line.MustBeDeclaration && !Contexts.front().InCtorInitializer)
Contexts.back().IsExpression = false;
Fix formatting of new arrays of pointers. Before: A = new SomeType * [Length]; A = new SomeType *[Length](); After: A = new SomeType *[Length]; A = new SomeType *[Length](); Small formatting cleanups with clang-format. llvm-svn: 176936
2013-03-13 15:49:51 +08:00
} else if (Current.is(tok::kw_new)) {
Contexts.back().CanBeExpression = false;
[clang] Refactoring of conditions so they use isOneOf() instead of multiple is(). llvm-svn: 240008
2015-06-18 18:59:26 +08:00
} else if (Current.isOneOf(tok::semi, tok::exclaim)) {
Fix expression recognition in for-loops. Before: for (; a&& b;) {} After: for (; a && b;) {} llvm-svn: 181017
2013-05-03 22:41:24 +08:00
// This should be the condition or increment in a for-loop.
Contexts.back().IsExpression = true;
Formatter: Correctly format stars in `sizeof(int**)` and similar places. This redoes how '*' and '&' are classified as pointer / reference markers when followed by ')', '>', or ','. Previously, determineStarAmpUsage() marked a single '*' and '&' followed by ')', '>', or ',' as pointer or reference marker. Now, all '*'s and '&'s preceding ')', '>', or ',' are marked as pointer / reference markers. Fixes PR14884. Since only the last '*' in 'int ***' was marked as pointer before (the rest were unary operators, which don't reach spaceRequiredBetween()), spaceRequiredBetween() now had to be thought about handing multiple '*'s in sequence. Before: return sizeof(int * *); Type **A = static_cast<Type * *>(P); Now: return sizeof(int**); Type **A = static_cast<Type **>(P); While here, also make all methods of AnnotatingParser except parseLine() private. Review URL: http://llvm-reviews.chandlerc.com/D384 llvm-svn: 174975
2013-02-13 00:17:07 +08:00
}
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
}
Restructuring of token annotation for formatting. This combines several changes: * Calculation token type (e.g. for * and &) in the AnnotatingParser. * Calculate the scope binding strength in the AnnotatingParser. * Let <> and [] scopes bind stronger than () and {} scopes. * Add minimal debugging output. llvm-svn: 174307
2013-02-04 15:21:18 +08:00
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
void determineTokenType(FormatToken &Current) {
if (!Current.is(TT_Unknown))
// The token type is already known.
return;
clang-format: [JS] allow breaking after non-null assertions. Summary: Previously clang-format would not break after any !. However in TypeScript, ! can be used as a post fix operator for non-nullability: x.foo()!.bar()!; With this change, clang-format will wrap after the ! if it is likely a post-fix non null operator. Reviewers: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D30705 llvm-svn: 297606
2017-03-13 17:14:23 +08:00
if (Style.Language == FormatStyle::LK_JavaScript) {
if (Current.is(tok::exclaim)) {
if (Current.Previous &&
clang-format: [JS] fix non-null assertion operator recognition. Summary: `getIdentifierInfo()` includes all keywords, whereas non-null assertion operators should only be recognized after non-keywords or pseudo keywords. Ideally this should list all tokens that clang-format recognizes as a keyword, but that are pseudo or no keywords in JS. For the time being, just recognize the specific bits users ran into (`namespace` in this case). Reviewers: djasper Subscribers: klimek Differential Revision: https://reviews.llvm.org/D33182 llvm-svn: 303038
2017-05-15 16:15:53 +08:00
(Current.Previous->isOneOf(tok::identifier, tok::kw_namespace,
tok::r_paren, tok::r_square,
tok::r_brace) ||
clang-format: [JS] allow breaking after non-null assertions. Summary: Previously clang-format would not break after any !. However in TypeScript, ! can be used as a post fix operator for non-nullability: x.foo()!.bar()!; With this change, clang-format will wrap after the ! if it is likely a post-fix non null operator. Reviewers: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D30705 llvm-svn: 297606
2017-03-13 17:14:23 +08:00
Current.Previous->Tok.isLiteral())) {
Current.Type = TT_JsNonNullAssertion;
return;
}
if (Current.Next &&
Current.Next->isOneOf(TT_BinaryOperator, Keywords.kw_as)) {
Current.Type = TT_JsNonNullAssertion;
return;
}
}
}
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
// Line.MightBeFunctionDecl can only be true after the parentheses of a
// function declaration have been found. In this case, 'Current' is a
// trailing token of this declaration and thus cannot be a name.
if (Current.is(Keywords.kw_instanceof)) {
Current.Type = TT_BinaryOperator;
} else if (isStartOfName(Current) &&
(!Line.MightBeFunctionDecl || Current.NestingLevel != 0)) {
Contexts.back().FirstStartOfName = &Current;
Current.Type = TT_StartOfName;
clang-format: Fix formatting of for loops with multiple increments. This fixes llvm.org/PR34366. llvm-svn: 312437
2017-09-03 16:56:24 +08:00
} 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;
Add support for GCC's '__auto_type' extension, per the GCC manual: https://gcc.gnu.org/onlinedocs/gcc/Typeof.html Differences from the GCC extension: * __auto_type is also permitted in C++ (but only in places where it could appear in C), allowing its use in headers that might be shared across C and C++, or used from C++98 * __auto_type can be combined with a declarator, as with C++ auto (for instance, "__auto_type *p") * multiple variables can be declared in a single __auto_type declaration, with the C++ semantics (the deduced type must be the same in each case) This patch also adds a missing restriction on applying typeof to a bit-field, which GCC has historically rejected in C (due to lack of clarity as to whether the operand should be promoted). The same restriction also applies to __auto_type in C (in both GCC and Clang). This also fixes PR25449. Patch by Nicholas Allegra! llvm-svn: 252690
2015-11-11 10:02:15 +08:00
} else if (Current.isOneOf(tok::kw_auto, tok::kw___auto_type)) {
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
AutoFound = true;
} else if (Current.is(tok::arrow) &&
Style.Language == FormatStyle::LK_Java) {
Current.Type = TT_LambdaArrow;
} else if (Current.is(tok::arrow) && AutoFound && Line.MustBeDeclaration &&
Current.NestingLevel == 0) {
Current.Type = TT_TrailingReturnArrow;
} else if (Current.isOneOf(tok::star, tok::amp, tok::ampamp)) {
clang-format clang-format. llvm-svn: 313744
2017-09-20 17:51:03 +08:00
Current.Type = determineStarAmpUsage(Current,
Contexts.back().CanBeExpression &&
Contexts.back().IsExpression,
Contexts.back().InTemplateArgument);
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
} else if (Current.isOneOf(tok::minus, tok::plus, tok::caret)) {
Current.Type = determinePlusMinusCaretUsage(Current);
if (Current.is(TT_UnaryOperator) && Current.is(tok::caret))
Contexts.back().CaretFound = true;
} else if (Current.isOneOf(tok::minusminus, tok::plusplus)) {
Current.Type = determineIncrementUsage(Current);
} else if (Current.isOneOf(tok::exclaim, tok::tilde)) {
Current.Type = TT_UnaryOperator;
} else if (Current.is(tok::question)) {
clang-format: [JS] support optional methods. Optional methods use ? tokens like this: interface X { y?(): z; } It seems easiest to detect and disambiguate these from ternary expressions by checking if the code is in a declaration context. Turns out that that didn't quite work properly for interfaces in Java and JS, and for JS file root contexts. Patch by Martin Probst, thank you. llvm-svn: 236488
2015-05-05 16:40:32 +08:00
if (Style.Language == FormatStyle::LK_JavaScript &&
clang-format: [JS] handle conditionals in fields, default params. Summary: Reviewers: djasper Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D21658 llvm-svn: 273619
2016-06-24 05:51:49 +08:00
Line.MustBeDeclaration && !Contexts.back().IsExpression) {
clang-format: [JS] support optional methods. Optional methods use ? tokens like this: interface X { y?(): z; } It seems easiest to detect and disambiguate these from ternary expressions by checking if the code is in a declaration context. Turns out that that didn't quite work properly for interfaces in Java and JS, and for JS file root contexts. Patch by Martin Probst, thank you. llvm-svn: 236488
2015-05-05 16:40:32 +08:00
// In JavaScript, `interface X { foo?(): bar; }` is an optional method
// on the interface, not a ternary expression.
Current.Type = TT_JsTypeOptionalQuestion;
} else {
Current.Type = TT_ConditionalExpr;
}
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
} else if (Current.isBinaryOperator() &&
[clang-format] Adds space around angle brackets in text protos Summary: This patch adds spaces around angle brackets in text proto Google style. Previously these were detected as template openers and closers, which happened to have the expected effect. Now we detect them as scope openers and closers similarly to the way braces are handled in this context. Reviewers: djasper Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D42727 llvm-svn: 324337
2018-02-06 19:34:34 +08:00
(!Current.Previous || Current.Previous->isNot(tok::l_square)) &&
(!Current.is(tok::greater) &&
Style.Language != FormatStyle::LK_TextProto)) {
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
Current.Type = TT_BinaryOperator;
} else if (Current.is(tok::comment)) {
clang-format: Prevent assertion discovered by fuzzer. llvm-svn: 236578
2015-05-06 16:58:57 +08:00
if (Current.TokenText.startswith("/*")) {
if (Current.TokenText.endswith("*/"))
Current.Type = 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.Type = TT_LineComment;
}
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
} else if (Current.is(tok::r_paren)) {
if (rParenEndsCast(Current))
Current.Type = TT_CastRParen;
clang-format: Improve detection of macros annotating functions. Before: ASSERT("aaaaaaaaaaaaaaa") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; After: ASSERT("aaaaaaaaaaaaaaa") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; Also cleanup implementation a bit and only mark closing parenthesis of these annotations. llvm-svn: 237567
2015-05-18 21:47:23 +08:00
if (Current.MatchingParen && Current.Next &&
!Current.Next->isBinaryOperator() &&
clang-format: Fix incorrect function annotation detection. Before: MACRO( abc).function() // wrap << abc; After: MACRO(abc).function() // wrap << abc; llvm-svn: 265540
2016-04-06 21:58:09 +08:00
!Current.Next->isOneOf(tok::semi, tok::colon, tok::l_brace,
clang-format: [Java] Fix bug in enum formatting. Before: public enum VeryLongEnum { ENUM_WITH_MANY_PARAMETERS("aaaaaaaaaaaaaaaaaaaaaa", "bbbbbbbbbbbbbbbbbbbbbbbbbbb", "ccccccccccccccccccc") , SECOND_ENUM("a", "b", "c"); private VeryLongEnum(String a, String b, String c) {} } After: public enum VeryLongEnum { ENUM_WITH_MANY_PARAMETERS("aaaaaaaaaaaaaaaaaaaaaa", "bbbbbbbbbbbbbbbbbbbbbbbbbbb", "ccccccccccccccccccc") , SECOND_ENUM("a", "b", "c"); private VeryLongEnum(String a, String b, String c) {} } llvm-svn: 296499
2017-03-01 02:28:15 +08:00
tok::comma, tok::period, tok::arrow,
tok::coloncolon))
[clang-format] Don't allow newline after uppercase Obj-C block return types Fixes the following: BOOL (^aaa)(void) = ^BOOL { }; The first BOOL's token was getting set to TT_FunctionAnnotationRParen incorrectly, which was causing an unexpected newline after (^aaa). This was introduced in r245846. Patch by Kent Sutherland, thank you! llvm-svn: 282448
2016-09-27 06:19:08 +08:00
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->TokenText == BeforeParen->TokenText.upper() &&
(!BeforeParen->Previous ||
BeforeParen->Previous->ClosesTemplateDeclaration))
Current.Type = TT_FunctionAnnotationRParen;
}
}
clang-format: [JS/Java] ignore Objective-C constructs in JS & Java. Summary: Java and JavaScript support annotations and decorators, respectively, that use a leading "@" token. clang-format currently detects this as an Objective-C construct and applies special formatting, for example no whitespace around "=" operators. This change disables the distinction for Java and JavaScript, which leads to normal formatting of single line annotated and initialized properties. Before: class X { @foo() bar=false; } After: class X { @foo() bar = false; } Reviewers: djasper, bkramer Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D32532 llvm-svn: 301399
2017-04-26 20:36:49 +08:00
} 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.
[clang-format] Handle NSString literals by merging tokens. Summary: This fixes a few outstanding bugs: * incorrect breaking of NSString literals containing double-width characters; * inconsistent formatting of ObjC dictionary literals containing NSString literals; * AlwaysBreakBeforeMultilineStrings ignoring implicitly-concatenated NSString literals. Reviewers: djasper Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D31706 llvm-svn: 299927
2017-04-11 17:55:00 +08:00
switch (Current.Next->Tok.getObjCKeywordID()) {
case tok::objc_interface:
case tok::objc_implementation:
case tok::objc_protocol:
Current.Type = TT_ObjCDecl;
break;
case tok::objc_property:
Current.Type = TT_ObjCProperty;
break;
default:
break;
Reverting r222638; it broke the MSVC build bots because Visual Studio 2012 does not support variadic templates. Also reverting r222641 because it was relying on 222638. llvm-svn: 222656
2014-11-24 23:42:34 +08:00
}
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
} else if (Current.is(tok::period)) {
FormatToken *PreviousNoComment = Current.getPreviousNonComment();
if (PreviousNoComment &&
PreviousNoComment->isOneOf(tok::comma, tok::l_brace))
Current.Type = TT_DesignatedInitializerPeriod;
clang-format: [Java] Support formatting qualified annotations. llvm-svn: 225559
2015-01-10 07:25:06 +08:00
else if (Style.Language == FormatStyle::LK_Java && Current.Previous &&
Current.Previous->isOneOf(TT_JavaAnnotation,
TT_LeadingJavaAnnotation)) {
Current.Type = Current.Previous->Type;
}
[clang-format/ObjC] Use getIdentifierInfo() instead of tok::identifier Summary: Previously, we checked tokens for `tok::identifier` to see if they were identifiers inside an Objective-C selector. However, this missed C++ keywords like `new` and `delete`. To fix this, this diff uses `getIdentifierInfo()` to find identifiers or keywords inside Objective-C selectors. Test Plan: New tests added. Ran tests with: % make -j16 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: djasper, jolesiak Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D46143 llvm-svn: 331067
2018-04-28 02:51:12 +08:00
} else if (canBeObjCSelectorComponent(Current) &&
[clang-format] Ensure ObjC selectors with 0 args are annotated correctly Summary: Previously, clang-format would incorrectly annotate 0-argument Objective-C selector names as TT_TrailingAnnotation: ``` % echo "-(void)foo;" > /tmp/test.m % ./bin/clang-format -debug /tmp/test.m Language: Objective-C ---- Line(0, FSC=0): minus[T=68, OC=0] l_paren[T=68, OC=1] void[T=68, OC=2] r_paren[T=68, OC=6] identifier[T=68, OC=7] semi[T=68, OC=10] Line(0, FSC=0): eof[T=68, OC=0] Run 0... AnnotatedTokens(L=0): M=0 C=0 T=ObjCMethodSpecifier S=1 B=0 BK=0 P=0 Name=minus L=1 PPK=2 FakeLParens= FakeRParens=0 Text='-' M=0 C=1 T=Unknown S=1 B=0 BK=0 P=33 Name=l_paren L=3 PPK=2 FakeLParens= FakeRParens=0 Text='(' M=0 C=1 T=Unknown S=0 B=0 BK=0 P=140 Name=void L=7 PPK=2 FakeLParens= FakeRParens=0 Text='void' M=0 C=0 T=CastRParen S=0 B=0 BK=0 P=43 Name=r_paren L=8 PPK=2 FakeLParens= FakeRParens=0 Text=')' M=0 C=1 T=TrailingAnnotation S=0 B=0 BK=0 P=120 Name=identifier L=11 PPK=2 FakeLParens= FakeRParens=0 Text='foo' M=0 C=0 T=Unknown S=0 B=0 BK=0 P=23 Name=semi L=12 PPK=2 FakeLParens= FakeRParens=0 Text=';' ``` This caused us to incorrectly indent 0-argument wrapped selectors when Style.IndentWrappedFunctionNames was false, as we thought the 0-argument ObjC selector name was actually a trailing annotation (which is always indented). This diff fixes the issue and adds tests. Test Plan: New tests added. Confirmed tests failed before diff. After diff, tests passed. Ran tests with: % make -j12 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: djasper, jolesiak Reviewed By: djasper, jolesiak Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D44996 llvm-svn: 329297
2018-04-05 23:26:23 +08:00
// 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.Type = TT_SelectorName;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
} else if (Current.isOneOf(tok::identifier, tok::kw_const) &&
Current.Previous &&
!Current.Previous->isOneOf(tok::equal, tok::at) &&
Line.MightBeFunctionDecl && Contexts.size() == 1) {
// Line.MightBeFunctionDecl can only be true after the parentheses of a
// function declaration have been found.
Current.Type = TT_TrailingAnnotation;
clang-format: [JS] support AtScript style annotations for JS. Based on Java annotation support and style. Patch by Martin Probst. llvm-svn: 229703
2015-02-19 01:17:15 +08:00
} else if ((Style.Language == FormatStyle::LK_Java ||
Style.Language == FormatStyle::LK_JavaScript) &&
Current.Previous) {
clang-format: [Java] Support formatting qualified annotations. llvm-svn: 225559
2015-01-10 07:25:06 +08:00
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.Type = TT_LeadingJavaAnnotation;
else
Current.Type = TT_JavaAnnotation;
} else if (Current.Previous->is(tok::period) &&
Current.Previous->isOneOf(TT_JavaAnnotation,
TT_LeadingJavaAnnotation)) {
Current.Type = Current.Previous->Type;
}
Restructuring of token annotation for formatting. This combines several changes: * Calculation token type (e.g. for * and &) in the AnnotatingParser. * Calculate the scope binding strength in the AnnotatingParser. * Let <> and [] scopes bind stronger than () and {} scopes. * Add minimal debugging output. llvm-svn: 174307
2013-02-04 15:21:18 +08:00
}
}
Remove \brief commands from doxygen comments. This is similar to the LLVM change https://reviews.llvm.org/D46290. We've been running doxygen with the autobrief option for a couple of years now. This makes the \brief markers into our comments redundant. Since they are a visual distraction and we don't want to encourage more \brief markers in new code either, this patch removes them all. Patch produced by for i in $(git grep -l '\@brief'); do perl -pi -e 's/\@brief //g' $i & done for i in $(git grep -l '\\brief'); do perl -pi -e 's/\\brief //g' $i & done Differential Revision: https://reviews.llvm.org/D46320 llvm-svn: 331834
2018-05-09 09:00:01 +08:00
/// Take a guess at whether \p Tok starts a name of a function or
Fix formatting of long declarations with const type. Before (exceeding the column limit): LoooooooooooooooooooooooooooooooooooooooongType const LoooooooooooooooooooooooooooooooooooooooongVariable; After: LoooooooooooooooooooooooooooooooooooooooongType const LoooooooooooooooooooooooooooooooooooooooongVariable; llvm-svn: 185418
2013-07-02 17:47:29 +08:00
/// 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) {
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
if (Tok.isNot(tok::identifier) || !Tok.Previous)
Fix formatting of long declarations with const type. Before (exceeding the column limit): LoooooooooooooooooooooooooooooooooooooooongType const LoooooooooooooooooooooooooooooooooooooooongVariable; After: LoooooooooooooooooooooooooooooooooooooooongType const LoooooooooooooooooooooooooooooooooooooooongVariable; llvm-svn: 185418
2013-07-02 17:47:29 +08:00
return false;
clang-format: [JS/TS] Properly understand cast expressions. Many things were wrong: - We didn't always allow wrapping after "as", which can be necessary. - We used to Undestand the identifier after "as" as a start of a name. - We didn't properly parse the structure of the expression with "as" having the precedence of relational operators llvm-svn: 296659
2017-03-02 03:26:12 +08:00
if (Tok.Previous->isOneOf(TT_LeadingJavaAnnotation, Keywords.kw_instanceof,
Keywords.kw_as))
clang-format: Space and triple angle braces. Committing patch http://reviews.llvm.org/D6800. llvm-svn: 229783
2015-02-19 07:48:37 +08:00
return false;
clang-format: [JS] Treat "in" as a proper operator. llvm-svn: 259350
2016-02-01 19:20:47 +08:00
if (Style.Language == FormatStyle::LK_JavaScript &&
Tok.Previous->is(Keywords.kw_in))
return false;
clang-format: [Java] Don't let annotations confuse return type analysis. Before: @Test ReturnType doSomething(String aaaaaaaaaaaaa, String bbbbbbbbbbbbbbb) {} After: @Test ReturnType doSomething( String aaaaaaaaaaaaa, String bbbbbbbbbbbbbbb) {} llvm-svn: 225964
2015-01-14 18:00:20 +08:00
Fix formatting of long declarations with const type. Before (exceeding the column limit): LoooooooooooooooooooooooooooooooooooooooongType const LoooooooooooooooooooooooooooooooooooooooongVariable; After: LoooooooooooooooooooooooooooooooooooooooongType const LoooooooooooooooooooooooooooooooooooooooongVariable; llvm-svn: 185418
2013-07-02 17:47:29 +08:00
// Skip "const" as it does not have an influence on whether this is a name.
[clang-format] Fixed indent issue when adding a comment at the end of a return type in named function declaration. Differential Revision: https://reviews.llvm.org/D30646 llvm-svn: 297143
2017-03-07 22:48:02 +08:00
FormatToken *PreviousNotConst = Tok.getPreviousNonComment();
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
while (PreviousNotConst && PreviousNotConst->is(tok::kw_const))
[clang-format] Fixed indent issue when adding a comment at the end of a return type in named function declaration. Differential Revision: https://reviews.llvm.org/D30646 llvm-svn: 297143
2017-03-07 22:48:02 +08:00
PreviousNotConst = PreviousNotConst->getPreviousNonComment();
Fix formatting of long declarations with const type. Before (exceeding the column limit): LoooooooooooooooooooooooooooooooooooooooongType const LoooooooooooooooooooooooooooooooooooooooongVariable; After: LoooooooooooooooooooooooooooooooooooooooongType const LoooooooooooooooooooooooooooooooooooooooongVariable; llvm-svn: 185418
2013-07-02 17:47:29 +08:00
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
if (!PreviousNotConst)
Fix formatting of long declarations with const type. Before (exceeding the column limit): LoooooooooooooooooooooooooooooooooooooooongType const LoooooooooooooooooooooooooooooooooooooooongVariable; After: LoooooooooooooooooooooooooooooooooooooooongType const LoooooooooooooooooooooooooooooooooooooooongVariable; llvm-svn: 185418
2013-07-02 17:47:29 +08:00
return false;
Reformat clang-format's source files after r185822 and others. llvm-svn: 185823
2013-07-08 22:34:09 +08:00
bool IsPPKeyword = PreviousNotConst->is(tok::identifier) &&
PreviousNotConst->Previous &&
PreviousNotConst->Previous->is(tok::hash);
Fix formatting of long declarations with const type. Before (exceeding the column limit): LoooooooooooooooooooooooooooooooooooooooongType const LoooooooooooooooooooooooooooooooooooooooongVariable; After: LoooooooooooooooooooooooooooooooooooooooongType const LoooooooooooooooooooooooooooooooooooooooongVariable; llvm-svn: 185418
2013-07-02 17:47:29 +08:00
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (PreviousNotConst->is(TT_TemplateCloser))
clang-format: Fix return type line break decision. This accidentally introduced by r186077, as function names were not correctly recognized in templated declarations. Before: template <class TemplateIt> SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end, TemplateIt* stop) {} After: template <class TemplateIt> SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end, TemplateIt* stop) {} llvm-svn: 188665
2013-08-19 18:16:18 +08:00
return PreviousNotConst && PreviousNotConst->MatchingParen &&
PreviousNotConst->MatchingParen->Previous &&
clang-format: [Java] Don't force break before generic type method. Before: Foo.bar() .<X> baz(); After: Foo.bar() .<X>baz(); Patch by Harry Terkelsen. llvm-svn: 222423
2014-11-20 17:48:11 +08:00
PreviousNotConst->MatchingParen->Previous->isNot(tok::period) &&
clang-format: Fix return type line break decision. This accidentally introduced by r186077, as function names were not correctly recognized in templated declarations. Before: template <class TemplateIt> SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end, TemplateIt* stop) {} After: template <class TemplateIt> SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end, TemplateIt* stop) {} llvm-svn: 188665
2013-08-19 18:16:18 +08:00
PreviousNotConst->MatchingParen->Previous->isNot(tok::kw_template);
clang-format: Understand functions with decltype return type. Before: decltype(long_name_forcing_break) f() {} After: decltype(long_name_forcing_break) f() {} llvm-svn: 207965
2014-05-05 21:48:09 +08:00
if (PreviousNotConst->is(tok::r_paren) && PreviousNotConst->MatchingParen &&
PreviousNotConst->MatchingParen->Previous &&
PreviousNotConst->MatchingParen->Previous->is(tok::kw_decltype))
return true;
clang-format: Add space before member function reference qualifiers. Before: SomeType MemberFunction(const Deleted &)&; After: SomeType MemberFunction(const Deleted &) &; Seems to be much more common. llvm-svn: 245934
2015-08-25 21:40:51 +08:00
return (!IsPPKeyword &&
PreviousNotConst->isOneOf(tok::identifier, tok::kw_auto)) ||
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
PreviousNotConst->is(TT_PointerOrReference) ||
clang-format: Enable formatting of lambdas with explicit return type. So clang-format can now format: int c = []()->int { return 2; }(); int c = []()->vector<int> { return { 2 }; }(); llvm-svn: 199368
2014-01-16 17:11:55 +08:00
PreviousNotConst->isSimpleTypeSpecifier();
Fix formatting of long declarations with const type. Before (exceeding the column limit): LoooooooooooooooooooooooooooooooooooooooongType const LoooooooooooooooooooooooooooooooooooooooongVariable; After: LoooooooooooooooooooooooooooooooooooooooongType const LoooooooooooooooooooooooooooooooooooooooongVariable; llvm-svn: 185418
2013-07-02 17:47:29 +08:00
}
Remove \brief commands from doxygen comments. This is similar to the LLVM change https://reviews.llvm.org/D46290. We've been running doxygen with the autobrief option for a couple of years now. This makes the \brief markers into our comments redundant. Since they are a visual distraction and we don't want to encourage more \brief markers in new code either, this patch removes them all. Patch produced by for i in $(git grep -l '\@brief'); do perl -pi -e 's/\@brief //g' $i & done for i in $(git grep -l '\\brief'); do perl -pi -e 's/\\brief //g' $i & done Differential Revision: https://reviews.llvm.org/D46320 llvm-svn: 331834
2018-05-09 09:00:01 +08:00
/// Determine whether ')' is ending a cast.
Pulled out cast detection in TokenAnnotator into its own function This is to remove FIXME added in r207964. Differential Revision: http://reviews.llvm.org/D3619 llvm-svn: 208071
2014-05-06 17:08:34 +08:00
bool rParenEndsCast(const FormatToken &Tok) {
clang-format: Signficantly refactor the cast detection. No functional changes intended. llvm-svn: 253873
2015-11-23 23:55:55 +08:00
// C-style casts are only used in C++ and Java.
clang-format: Fix post-commit review comment of r299204, use Style.isCpp(). Also, while at it, s/IsCpp/isCpp/ so that it follows LLVM style. llvm-svn: 299214
2017-03-31 21:30:24 +08:00
if (!Style.isCpp() && Style.Language != FormatStyle::LK_Java)
clang-format: Signficantly refactor the cast detection. No functional changes intended. llvm-svn: 253873
2015-11-23 23:55:55 +08:00
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;
clang-format: Fix incorrect cast detection. Before: bool b = f(g<int>)&&c; After: bool b = f(g<int>) && c; llvm-svn: 253872
2015-11-23 23:55:50 +08:00
clang-format: Signficantly refactor the cast detection. No functional changes intended. llvm-svn: 253873
2015-11-23 23:55:55 +08:00
FormatToken *LeftOfParens = Tok.MatchingParen->getPreviousNonComment();
clang-format: Fix incorrect cast detection. Before: bool b = f(g<int>)&&c; After: bool b = f(g<int>) && c; llvm-svn: 253872
2015-11-23 23:55:50 +08:00
if (LeftOfParens) {
clang-format: Fix incorrect cast detection. Before: auto s = sizeof...(Ts)-1; After: auto s = sizeof...(Ts) - 1; llvm-svn: 272536
2016-06-13 15:49:09 +08:00
// If there is a closing parenthesis left of the current parentheses,
clang-format: Re-add code path deleted in r253873 and add missing test. llvm-svn: 253900
2015-11-24 03:11:45 +08:00
// 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;
}
clang-format: Signficantly refactor the cast detection. No functional changes intended. llvm-svn: 253873
2015-11-23 23:55:55 +08:00
// If there is an identifier (or with a few exceptions a keyword) right
// before the parentheses, this is unlikely to be a cast.
clang-format: Fix incorrect cast detection. Before: bool b = f(g<int>)&&c; After: bool b = f(g<int>) && c; llvm-svn: 253872
2015-11-23 23:55:50 +08:00
if (LeftOfParens->Tok.getIdentifierInfo() &&
!LeftOfParens->isOneOf(Keywords.kw_in, tok::kw_return, tok::kw_case,
tok::kw_delete))
return false;
clang-format: Signficantly refactor the cast detection. No functional changes intended. llvm-svn: 253873
2015-11-23 23:55:55 +08:00
// 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,
clang-format: Fix incorrect cast detection. Before: auto s = sizeof...(Ts)-1; After: auto s = sizeof...(Ts) - 1; llvm-svn: 272536
2016-06-13 15:49:09 +08:00
TT_TemplateCloser, tok::ellipsis))
clang-format: Fix incorrect cast detection. Before: bool b = f(g<int>)&&c; After: bool b = f(g<int>) && c; llvm-svn: 253872
2015-11-23 23:55:50 +08:00
return false;
clang-format: [Java] Improve cast detection. Before: a[b >> 1] = (byte)(c() << 4); After: a[b >> 1] = (byte) (c() << 4); llvm-svn: 222827
2014-11-26 20:23:10 +08:00
}
clang-format: Signficantly refactor the cast detection. No functional changes intended. llvm-svn: 253873
2015-11-23 23:55:55 +08:00
if (Tok.Next->is(tok::question))
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.
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
bool ParensAreType =
!Tok.Previous ||
Tok.Previous->isOneOf(TT_PointerOrReference, TT_TemplateCloser) ||
Tok.Previous->isSimpleTypeSpecifier();
Pulled out cast detection in TokenAnnotator into its own function This is to remove FIXME added in r207964. Differential Revision: http://reviews.llvm.org/D3619 llvm-svn: 208071
2014-05-06 17:08:34 +08:00
bool ParensCouldEndDecl =
clang-format: Fix false positive in cast detection. Before (with spaces in parentheses): void inFunction() { std::function<void( int, int )> fct; } After: void inFunction() { std::function<void( int, int)> fct; } llvm-svn: 251284
2015-10-26 20:08:47 +08:00
Tok.Next->isOneOf(tok::equal, tok::semi, tok::l_brace, tok::greater);
clang-format: Fix incorrect function type detection. Before: int x = f (&h)(); After: int x = f(&h)(); llvm-svn: 256488
2015-12-28 15:44:25 +08:00
if (ParensAreType && !ParensCouldEndDecl)
clang-format: Signficantly refactor the cast detection. No functional changes intended. llvm-svn: 253873
2015-11-23 23:55:55 +08:00
return true;
Pulled out cast detection in TokenAnnotator into its own function This is to remove FIXME added in r207964. Differential Revision: http://reviews.llvm.org/D3619 llvm-svn: 208071
2014-05-06 17:08:34 +08:00
clang-format: Signficantly refactor the cast detection. No functional changes intended. llvm-svn: 253873
2015-11-23 23:55:55 +08:00
// 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;
clang-format: Support ObjC selectors with unnamed parameters. This fixes llvm.org/PR28063. llvm-svn: 286715
2016-11-12 15:38:22 +08:00
// 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;
clang-format: Fix cast detection on "this". Before: auto x = (X) this; After: auto x = (X)this; This fixes llvm.org/PR27198. llvm-svn: 265385
2016-04-05 19:46:06 +08:00
// 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))
clang-format: Signficantly refactor the cast detection. No functional changes intended. llvm-svn: 253873
2015-11-23 23:55:55 +08:00
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;
Pulled out cast detection in TokenAnnotator into its own function This is to remove FIXME added in r207964. Differential Revision: http://reviews.llvm.org/D3619 llvm-svn: 208071
2014-05-06 17:08:34 +08:00
}
clang-format: Signficantly refactor the cast detection. No functional changes intended. llvm-svn: 253873
2015-11-23 23:55:55 +08:00
return true;
Pulled out cast detection in TokenAnnotator into its own function This is to remove FIXME added in r207964. Differential Revision: http://reviews.llvm.org/D3619 llvm-svn: 208071
2014-05-06 17:08:34 +08:00
}
Remove \brief commands from doxygen comments. This is similar to the LLVM change https://reviews.llvm.org/D46290. We've been running doxygen with the autobrief option for a couple of years now. This makes the \brief markers into our comments redundant. Since they are a visual distraction and we don't want to encourage more \brief markers in new code either, this patch removes them all. Patch produced by for i in $(git grep -l '\@brief'); do perl -pi -e 's/\@brief //g' $i & done for i in $(git grep -l '\\brief'); do perl -pi -e 's/\\brief //g' $i & done Differential Revision: https://reviews.llvm.org/D46320 llvm-svn: 331834
2018-05-09 09:00:01 +08:00
/// Return the type of the given token assuming it is * or &.
Fix bool expression special case. Clang-format now correctly formats: some_type<a * b> v; template <bool a, bool b> typename enabled_if<a && b>::type f() {} llvm-svn: 204913
2014-03-27 19:17:36 +08:00
TokenType determineStarAmpUsage(const FormatToken &Tok, bool IsExpression,
bool InTemplateArgument) {
clang-format: [JS] JavaScript does not have the */&/&& madness. Before: e&& e.SomeFunction(); After: e && e.SomeFunction(); Yeah, this might be useful for C++, too, but it is not such a frequent pattern there (plus the fix is much harder). llvm-svn: 217237
2014-09-05 16:53:45 +08:00
if (Style.Language == FormatStyle::LK_JavaScript)
return TT_BinaryOperator;
Fixed typo: NoneComment -> NonComment, no other changes. llvm-svn: 185640
2013-07-04 22:47:51 +08:00
const FormatToken *PrevToken = Tok.getPreviousNonComment();
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
if (!PrevToken)
Restructuring of token annotation for formatting. This combines several changes: * Calculation token type (e.g. for * and &) in the AnnotatingParser. * Calculate the scope binding strength in the AnnotatingParser. * Let <> and [] scopes bind stronger than () and {} scopes. * Add minimal debugging output. llvm-svn: 174307
2013-02-04 15:21:18 +08:00
return TT_UnaryOperator;
Fixed typo: NoneComment -> NonComment, no other changes. llvm-svn: 185640
2013-07-04 22:47:51 +08:00
const FormatToken *NextToken = Tok.getNextNonComment();
clang-format: Get slightly better at understanding */&. Before: void f() { MACRO(A * const a); } After: void f() { MACRO(A *const a); } llvm-svn: 297268
2017-03-08 17:49:12 +08:00
if (!NextToken ||
NextToken->isOneOf(tok::arrow, tok::equal, tok::kw_const) ||
clang-format: Understand more lambda return types. Before: auto a = [&b, c ](D * d) -> D * {} After: auto a = [&b, c](D* d) -> D* {} llvm-svn: 222534
2014-11-21 22:08:38 +08:00
(NextToken->is(tok::l_brace) && !NextToken->getNextNonComment()))
clang-format: Make formatting of member function reference qualifiers more consistent. Before: SomeType MemberFunction(const Deleted &)&&; SomeType MemberFunction(const Deleted &) && { ... } After: SomeType MemberFunction(const Deleted &)&&; SomeType MemberFunction(const Deleted &)&& { ... } llvm-svn: 245843
2015-08-24 22:28:08 +08:00
return TT_PointerOrReference;
Restructuring of token annotation for formatting. This combines several changes: * Calculation token type (e.g. for * and &) in the AnnotatingParser. * Calculate the scope binding strength in the AnnotatingParser. * Let <> and [] scopes bind stronger than () and {} scopes. * Add minimal debugging output. llvm-svn: 174307
2013-02-04 15:21:18 +08:00
clang-format: Fix unary operator detection in corner case. Before: decltype(* ::std::declval<const T &>()) void F(); After: decltype(*::std::declval<const T &>()) void F(); llvm-svn: 216724
2014-08-29 20:54:38 +08:00
if (PrevToken->is(tok::coloncolon))
Correctly format arrays of pointers and function types. Before: void f(Type(*parameter)[10]) {} int(*func)(void *); After: void f(Type (*parameter)[10]) {} int (*func)(void *); llvm-svn: 176356
2013-03-02 01:13:29 +08:00
return TT_PointerOrReference;
Added AnnotatedToken::isOneOf + a few other refactorings Summary: <subj> Reviewers: djasper Reviewed By: djasper CC: cfe-commits, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D536 llvm-svn: 176951
2013-03-13 22:41:29 +08:00
if (PrevToken->isOneOf(tok::l_paren, tok::l_square, tok::l_brace,
Fix dereference formatting in for-loops. Before: for (char **a = b; * a; ++a) {} After: for (char **a = b; *a; ++a) {} llvm-svn: 177037
2013-03-14 18:50:25 +08:00
tok::comma, tok::semi, tok::kw_return, tok::colon,
Fix dereference of pointers in throw statements. Before: throw * x; After: throw *x; Patch by Erik Uhlmann. llvm-svn: 308185
2017-07-17 23:27:53 +08:00
tok::equal, tok::kw_delete, tok::kw_sizeof,
tok::kw_throw) ||
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
PrevToken->isOneOf(TT_BinaryOperator, TT_ConditionalExpr,
TT_UnaryOperator, TT_CastRParen))
Restructuring of token annotation for formatting. This combines several changes: * Calculation token type (e.g. for * and &) in the AnnotatingParser. * Calculate the scope binding strength in the AnnotatingParser. * Let <> and [] scopes bind stronger than () and {} scopes. * Add minimal debugging output. llvm-svn: 174307
2013-02-04 15:21:18 +08:00
return TT_UnaryOperator;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (NextToken->is(tok::l_square) && NextToken->isNot(TT_LambdaLSquare))
Formatter: No space after & and * in front of ObjC message expressions. 1. let determineStarAmp() check of unary operators before checking for "is next '['". That check was added in r173150, and the test from that revision passes either way. 2. change determineStarAmp() to categorize '*' and '&' after '=' as unary operator. 3. don't let parseSquare() overwrite the type of a '*' or '&' before the start of an objc message expression if has the role of unary operator. llvm-svn: 174489
2013-02-06 14:20:11 +08:00
return TT_PointerOrReference;
clang-format: Fix false positive in pointer/reference detection. Before: return options != nullptr &&operator==(*options); After: return options != nullptr && operator==(*options); llvm-svn: 249501
2015-10-07 09:41:14 +08:00
if (NextToken->is(tok::kw_operator) && !IsExpression)
return TT_PointerOrReference;
if (NextToken->isOneOf(tok::comma, tok::semi))
clang-format: Fix corner case in pointer/reference detection. llvm-svn: 211487
2014-06-23 15:36:18 +08:00
return TT_PointerOrReference;
Formatter: No space after & and * in front of ObjC message expressions. 1. let determineStarAmp() check of unary operators before checking for "is next '['". That check was added in r173150, and the test from that revision passes either way. 2. change determineStarAmp() to categorize '*' and '&' after '=' as unary operator. 3. don't let parseSquare() overwrite the type of a '*' or '&' before the start of an objc message expression if has the role of unary operator. llvm-svn: 174489
2013-02-06 14:20:11 +08:00
clang-format: Fix left pointer alignment after delctype/typeof Change 272124* introduced a regression in spaceRequiredBetween for left aligned pointers to decltype and typeof expressions. This fix adds logic to fix this. The test added is based on a related test in determineStarAmpUsage. Also add test cases for the regression. http://llvm.org/viewvc/llvm-project?view=revision&revision=272124 LLVM bug tracker: https://bugs.llvm.org/show_bug.cgi?id=30407 Differential revision: https://reviews.llvm.org/D35847 Fix contributed by euhlmann! llvm-svn: 310831
2017-08-14 19:06:07 +08:00
if (PrevToken->is(tok::r_paren) && PrevToken->MatchingParen) {
FormatToken *TokenBeforeMatchingParen =
PrevToken->MatchingParen->getPreviousNonComment();
if (TokenBeforeMatchingParen &&
TokenBeforeMatchingParen->isOneOf(tok::kw_typeof, tok::kw_decltype))
return TT_PointerOrReference;
}
clang-format: Understand function type typedefs with typeof. Before: typedef typeof(int(int, int)) * MyFunc; After: typedef typeof(int(int, int)) *MyFunc; This fixes llvm.org/PR17178. llvm-svn: 190401
2013-09-10 18:26:38 +08:00
Get rid of the adapted isLiteral method. We don't want to deviate from clang's standard terminology. llvm-svn: 204997
2014-03-28 17:27:09 +08:00
if (PrevToken->Tok.isLiteral() ||
PrevToken->isOneOf(tok::r_paren, tok::r_square, tok::kw_true,
clang-format: Improve && detection as binary operator. Before: template <class T, class = typename ::std::enable_if< ::std::is_array<T>{}&& ::std::is_array<T>{}>::type> void F(); After: template <class T, class = typename ::std::enable_if< ::std::is_array<T>{} && ::std::is_array<T>{}>::type> void F(); llvm-svn: 220813
2014-10-29 02:28:22 +08:00
tok::kw_false, tok::r_brace) ||
Get rid of the adapted isLiteral method. We don't want to deviate from clang's standard terminology. llvm-svn: 204997
2014-03-28 17:27:09 +08:00
NextToken->Tok.isLiteral() ||
NextToken->isOneOf(tok::kw_true, tok::kw_false) ||
NextToken->isUnaryOperator() ||
Fix bool expression special case. Clang-format now correctly formats: some_type<a * b> v; template <bool a, bool b> typename enabled_if<a && b>::type f() {} llvm-svn: 204913
2014-03-27 19:17:36 +08:00
// 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()))
Restructuring of token annotation for formatting. This combines several changes: * Calculation token type (e.g. for * and &) in the AnnotatingParser. * Calculate the scope binding strength in the AnnotatingParser. * Let <> and [] scopes bind stronger than () and {} scopes. * Add minimal debugging output. llvm-svn: 174307
2013-02-04 15:21:18 +08:00
return TT_BinaryOperator;
clang-format: Improve && detection as binary operators. Before: template <class T, class = typename std::enable_if<std::is_integral< T>::value &&(sizeof(T) > 1 || sizeof(T) < 8)>::type> void F(); After: template <class T, class = typename std::enable_if< std::is_integral<T>::value && (sizeof(T) > 1 || sizeof(T) < 8)>::type> void F(); llvm-svn: 220805
2014-10-29 02:11:52 +08:00
// "&&(" is quite unlikely to be two successive unary "&".
if (Tok.is(tok::ampamp) && NextToken && NextToken->is(tok::l_paren))
return TT_BinaryOperator;
clang-format: Fix special case of binary operator detection. There is a pattern where evaluation order is used as control flow. This patch special-cases a commonly occuring version of this pattern. Before: Aaaaa *aaa = nullptr; // ... aaa &&aaa->f(); After: Aaaaa *aaa = nullptr; // ... aaa && aaa->f(); llvm-svn: 210017
2014-06-02 19:54:20 +08:00
// This catches some cases where evaluation order is used as control flow:
// aaa && aaa->f();
const FormatToken *NextNextToken = NextToken->getNextNonComment();
if (NextNextToken && NextNextToken->is(tok::arrow))
return TT_BinaryOperator;
Restructuring of token annotation for formatting. This combines several changes: * Calculation token type (e.g. for * and &) in the AnnotatingParser. * Calculate the scope binding strength in the AnnotatingParser. * Let <> and [] scopes bind stronger than () and {} scopes. * Add minimal debugging output. llvm-svn: 174307
2013-02-04 15:21:18 +08:00
// It is very unlikely that we are going to find a pointer or reference type
// definition on the RHS of an assignment.
clang-format: Improve ObjC blocks with return type. Before: Block b = ^int * (A * a, B * b) {} After: Block b = ^int *(A *a, B *b) {} This fixed llvm.org/PR21619. llvm-svn: 222639
2014-11-24 03:15:35 +08:00
if (IsExpression && !Contexts.back().CaretFound)
Restructuring of token annotation for formatting. This combines several changes: * Calculation token type (e.g. for * and &) in the AnnotatingParser. * Calculate the scope binding strength in the AnnotatingParser. * Let <> and [] scopes bind stronger than () and {} scopes. * Add minimal debugging output. llvm-svn: 174307
2013-02-04 15:21:18 +08:00
return TT_BinaryOperator;
return TT_PointerOrReference;
}
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
TokenType determinePlusMinusCaretUsage(const FormatToken &Tok) {
Fixed typo: NoneComment -> NonComment, no other changes. llvm-svn: 185640
2013-07-04 22:47:51 +08:00
const FormatToken *PrevToken = Tok.getPreviousNonComment();
clang-format: [TypeScript] Fix bug in handling of non-null operator. Before: var i = x!-1; After: var i = x! - 1; llvm-svn: 286367
2016-11-09 22:12:55 +08:00
if (!PrevToken)
return TT_UnaryOperator;
[clang-format] fix handling of consecutive unary operators Summary: Code that used to be formatted as `if (! + object) {` is now formatted as `if (!+object) {` (we have a particular object in our codebase where unary `operator+` is overloaded to return the underlying value, which in this case is a `bool`) We still preserve the TypeScript behavior where `!` is a trailing non-null operator. (This is already tested by an existing unit test in `FormatTestJS.cpp`) It doesn't appear like handling of consecutive unary operators are tested in general, so I added another test for completeness Patch contributed by @kevinl! Reviewers: krasimir Reviewed By: krasimir Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D43312 llvm-svn: 326792
2018-03-06 21:56:28 +08:00
if (PrevToken->isOneOf(TT_CastRParen, TT_UnaryOperator))
// This must be a sequence of leading unary operators.
Restructuring of token annotation for formatting. This combines several changes: * Calculation token type (e.g. for * and &) in the AnnotatingParser. * Calculate the scope binding strength in the AnnotatingParser. * Let <> and [] scopes bind stronger than () and {} scopes. * Add minimal debugging output. llvm-svn: 174307
2013-02-04 15:21:18 +08:00
return TT_UnaryOperator;
// Use heuristics to recognize unary operators.
Added AnnotatedToken::isOneOf + a few other refactorings Summary: <subj> Reviewers: djasper Reviewed By: djasper CC: cfe-commits, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D536 llvm-svn: 176951
2013-03-13 22:41:29 +08:00
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))
Restructuring of token annotation for formatting. This combines several changes: * Calculation token type (e.g. for * and &) in the AnnotatingParser. * Calculate the scope binding strength in the AnnotatingParser. * Let <> and [] scopes bind stronger than () and {} scopes. * Add minimal debugging output. llvm-svn: 174307
2013-02-04 15:21:18 +08:00
return TT_UnaryOperator;
Formatter: Detect ObjC method expressions after unary operators. llvm-svn: 174384
2013-02-06 00:21:00 +08:00
// There can't be two consecutive binary operators.
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (PrevToken->is(TT_BinaryOperator))
Restructuring of token annotation for formatting. This combines several changes: * Calculation token type (e.g. for * and &) in the AnnotatingParser. * Calculate the scope binding strength in the AnnotatingParser. * Let <> and [] scopes bind stronger than () and {} scopes. * Add minimal debugging output. llvm-svn: 174307
2013-02-04 15:21:18 +08:00
return TT_UnaryOperator;
// Fall back to marking the token as binary operator.
return TT_BinaryOperator;
}
Remove \brief commands from doxygen comments. This is similar to the LLVM change https://reviews.llvm.org/D46290. We've been running doxygen with the autobrief option for a couple of years now. This makes the \brief markers into our comments redundant. Since they are a visual distraction and we don't want to encourage more \brief markers in new code either, this patch removes them all. Patch produced by for i in $(git grep -l '\@brief'); do perl -pi -e 's/\@brief //g' $i & done for i in $(git grep -l '\\brief'); do perl -pi -e 's/\\brief //g' $i & done Differential Revision: https://reviews.llvm.org/D46320 llvm-svn: 331834
2018-05-09 09:00:01 +08:00
/// Determine whether ++/-- are pre- or post-increments/-decrements.
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
TokenType determineIncrementUsage(const FormatToken &Tok) {
Fixed typo: NoneComment -> NonComment, no other changes. llvm-svn: 185640
2013-07-04 22:47:51 +08:00
const FormatToken *PrevToken = Tok.getPreviousNonComment();
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (!PrevToken || PrevToken->is(TT_CastRParen))
Restructuring of token annotation for formatting. This combines several changes: * Calculation token type (e.g. for * and &) in the AnnotatingParser. * Calculate the scope binding strength in the AnnotatingParser. * Let <> and [] scopes bind stronger than () and {} scopes. * Add minimal debugging output. llvm-svn: 174307
2013-02-04 15:21:18 +08:00
return TT_UnaryOperator;
Added AnnotatedToken::isOneOf + a few other refactorings Summary: <subj> Reviewers: djasper Reviewed By: djasper CC: cfe-commits, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D536 llvm-svn: 176951
2013-03-13 22:41:29 +08:00
if (PrevToken->isOneOf(tok::r_paren, tok::r_square, tok::identifier))
Restructuring of token annotation for formatting. This combines several changes: * Calculation token type (e.g. for * and &) in the AnnotatingParser. * Calculate the scope binding strength in the AnnotatingParser. * Let <> and [] scopes bind stronger than () and {} scopes. * Add minimal debugging output. llvm-svn: 174307
2013-02-04 15:21:18 +08:00
return TT_TrailingUnaryOperator;
return TT_UnaryOperator;
}
Handle nested ObjC calls. Properly handle annotation contexts while calculating extra information for each token. This enable nested ObjC calls and thus solves (most of) llvm.org/PR15164. E.g., we can now format: [contentsContainer replaceSubview:[subviews objectAtIndex:0] with:contentsNativeView]; Also fix a problem with the formatting of types in casts as this was trivial now. llvm-svn: 174498
2013-02-06 18:05:46 +08:00
SmallVector<Context, 8> Contexts;
clang-format: Add column layout formatting for braced lists With this patch, braced lists (with more than 3 elements are formatted in a column layout if possible). E.g.: static const uint16_t CallerSavedRegs64Bit[] = { X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI, X86::R8, X86::R9, X86::R10, X86::R11, 0 }; Required other changes: - FormatTokens can now have a special role that contains extra data and can do special formattings. A comma separated list is currently the only implementation. - Move penalty calculation entirely into ContinuationIndenter (there was a last piece still in UnwrappedLineFormatter). Review: http://llvm-reviews.chandlerc.com/D1457 llvm-svn: 189018
2013-08-22 23:00:41 +08:00
const FormatStyle &Style;
Handle nested ObjC calls. Properly handle annotation contexts while calculating extra information for each token. This enable nested ObjC calls and thus solves (most of) llvm.org/PR15164. E.g., we can now format: [contentsContainer replaceSubview:[subviews objectAtIndex:0] with:contentsNativeView]; Also fix a problem with the formatting of types in casts as this was trivial now. llvm-svn: 174498
2013-02-06 18:05:46 +08:00
AnnotatedLine &Line;
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
FormatToken *CurrentToken;
Initial support for formatting trailing return types. This fixes llvm.org/PR15170. For now, the basic formatting rules are (based on the C++11 standard): * Surround the "->" with spaces. * Break before "->". Also fix typo. llvm-svn: 185938
2013-07-09 22:36:48 +08:00
bool AutoFound;
clang-format: Use identifier table for keywords in other languages. Slightly easier to write, more efficient and prevents bugs by misspelling them. No functional changes intended. llvm-svn: 221259
2014-11-04 20:41:02 +08:00
const AdditionalKeywords &Keywords;
clang-format: Prevent exponential runtime in token annotator. llvm-svn: 236577
2015-05-06 16:38:24 +08:00
// 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;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
};
Make constant static variables const so they can go into a read-only section NFC. llvm-svn: 231597
2015-03-09 00:06:46 +08:00
static const int PrecedenceUnaryOperator = prec::PointerToMember + 1;
static const int PrecedenceArrowAndPeriod = prec::PointerToMember + 2;
clang-format: Revamp builder-type call formatting. Previously builder-type calls were only correctly recognized in top-level calls. This fixes llvm.org/PR16981. Before: someobj->Add((new util::filetools::Handler(dir))->OnEvent1( NewPermanentCallback(this, &HandlerHolderClass::EventHandlerCBA)) ->OnEvent2(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBB)) ->OnEvent3(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBC)) ->OnEvent5(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBD)) ->OnEvent6(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBE))); After: someobj->Add((new util::filetools::Handler(dir)) ->OnEvent1(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBA)) ->OnEvent2(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBB)) ->OnEvent3(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBC)) ->OnEvent5(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBD)) ->OnEvent6(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBE))); llvm-svn: 189337
2013-08-27 19:09:05 +08:00
Remove \brief commands from doxygen comments. This is similar to the LLVM change https://reviews.llvm.org/D46290. We've been running doxygen with the autobrief option for a couple of years now. This makes the \brief markers into our comments redundant. Since they are a visual distraction and we don't want to encourage more \brief markers in new code either, this patch removes them all. Patch produced by for i in $(git grep -l '\@brief'); do perl -pi -e 's/\@brief //g' $i & done for i in $(git grep -l '\\brief'); do perl -pi -e 's/\\brief //g' $i & done Differential Revision: https://reviews.llvm.org/D46320 llvm-svn: 331834
2018-05-09 09:00:01 +08:00
/// Parses binary expressions by inserting fake parenthesis based on
Implement a tiny expression parser to improve formatting decisions. With this patch, the formatter introduces 'fake' parenthesis according to the operator precedence of binary operators. Before: return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA || bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB || cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC || dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD; f(aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa); After: return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA || bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB || cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC || dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD; f(aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa); Future improvements: - Get rid of some of the hacky ways to nicely format certain constructs. - Merge this parser and the AnnotatingParser as we now have several parsers that analyze (), [], etc. llvm-svn: 174714
2013-02-08 23:28:42 +08:00
/// operator precedence.
class ExpressionParser {
public:
clang-format: Use identifier table for keywords in other languages. Slightly easier to write, more efficient and prevents bugs by misspelling them. No functional changes intended. llvm-svn: 221259
2014-11-04 20:41:02 +08:00
ExpressionParser(const FormatStyle &Style, const AdditionalKeywords &Keywords,
AnnotatedLine &Line)
: Style(Style), Keywords(Keywords), Current(Line.First) {}
Implement a tiny expression parser to improve formatting decisions. With this patch, the formatter introduces 'fake' parenthesis according to the operator precedence of binary operators. Before: return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA || bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB || cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC || dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD; f(aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa); After: return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA || bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB || cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC || dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD; f(aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa); Future improvements: - Get rid of some of the hacky ways to nicely format certain constructs. - Merge this parser and the AnnotatingParser as we now have several parsers that analyze (), [], etc. llvm-svn: 174714
2013-02-08 23:28:42 +08:00
Remove \brief commands from doxygen comments. This is similar to the LLVM change https://reviews.llvm.org/D46290. We've been running doxygen with the autobrief option for a couple of years now. This makes the \brief markers into our comments redundant. Since they are a visual distraction and we don't want to encourage more \brief markers in new code either, this patch removes them all. Patch produced by for i in $(git grep -l '\@brief'); do perl -pi -e 's/\@brief //g' $i & done for i in $(git grep -l '\\brief'); do perl -pi -e 's/\\brief //g' $i & done Differential Revision: https://reviews.llvm.org/D46320 llvm-svn: 331834
2018-05-09 09:00:01 +08:00
/// Parse expressions with the given operator precedence.
Better formatting of conditional expressions. In conditional expressions, if the condition is split over multiple lines, also break before both operands. This prevents formattings like: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ? b : c; Which are bad, because they suggestion incorrect operator precedence: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ? b : c); This lead to the discovery that the expression parser incorrectly handled conditional operators and that it could also handle semicolons (which in turn reduced the amount of special casing for for-loops). As a side-effect, we can now apply the bin-packing configuration to the sections of for-loops. llvm-svn: 175973
2013-02-24 05:01:55 +08:00
void parse(int Precedence = 0) {
clang-format: Improve ObjC variadic and binary expression parameters. Before: [self aaaaaaaaaaaaaaa:aaaaaaaaaaaaaaa | aaaaaaaaaaaaaaa | aaaaaaaaaaaaaaa | aaaaaaaaaaaaaaa | aaaaaaaaaaaaaaa | aaaaaaaaaaaaaaa | aaaaaaaaaaaaaaa | aaaaaaaaaaaaaaa]; [self aaaaaaaaaaaaaaa:aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaa]; After: [self aaaaaaaaaaaaaaa:aaaaaaaaaaaaaaa | aaaaaaaaaaaaaaa | aaaaaaaaaaaaaaa | aaaaaaaaaaaaaaa | aaaaaaaaaaaaaaa | aaaaaaaaaaaaaaa | aaaaaaaaaaaaaaa | aaaaaaaaaaaaaaa]; [self aaaaaaaaaaaaaaa:aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaa]; This addresses llvm.org/PR15349 and llvm.org/PR16185. llvm-svn: 194214
2013-11-08 03:23:49 +08:00
// Skip 'return' and ObjC selector colons as they are not part of a binary
// expression.
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
while (Current && (Current->is(tok::kw_return) ||
(Current->is(tok::colon) &&
Current->isOneOf(TT_ObjCMethodExpr, TT_DictLiteral))))
clang-format: Improve alignment after 'return'. Previously, comments, could totally confuse it. Before: return // true if code is one of a or b. code == a || code == b; After: return // true if code is one of a or b. code == a || code == b; llvm-svn: 191654
2013-09-30 16:29:03 +08:00
next();
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
if (!Current || Precedence > PrecedenceArrowAndPeriod)
clang-format: Fix indentation relative to unary expressions. This should be done, only if we are still in the unary expression's scope. Before: bool aaaa = !aaaaaaaa( // break aaaaaaaaaaa); *aaaaaa = aaaaaaa( // break aaaaaaaaaaaaaaaa); After: bool aaaa = !aaaaaaaa( // break aaaaaaaaaaa); // <- (unchanged) *aaaaaa = aaaaaaa( // break aaaaaaaaaaaaaaaa); // <- (no longer indented relative to "*") llvm-svn: 189108
2013-08-23 23:14:03 +08:00
return;
Properly format nested conditional operators. Before: bool aaaaaa = aaaaaaaaaaaaa // ? aaaaaaaaaaaaaaa : bbbbbbbbbbbbbbb // ? ccccccccccccccc : ddddddddddddddd; After: bool aaaaaa = aaaaaaaaaaaaa // ? aaaaaaaaaaaaaaa : bbbbbbbbbbbbbbb // ? ccccccccccccccc : ddddddddddddddd; llvm-svn: 183007
2013-05-31 22:56:12 +08:00
// Conditional expressions need to be parsed separately for proper nesting.
clang-format: Revamp builder-type call formatting. Previously builder-type calls were only correctly recognized in top-level calls. This fixes llvm.org/PR16981. Before: someobj->Add((new util::filetools::Handler(dir))->OnEvent1( NewPermanentCallback(this, &HandlerHolderClass::EventHandlerCBA)) ->OnEvent2(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBB)) ->OnEvent3(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBC)) ->OnEvent5(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBD)) ->OnEvent6(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBE))); After: someobj->Add((new util::filetools::Handler(dir)) ->OnEvent1(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBA)) ->OnEvent2(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBB)) ->OnEvent3(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBC)) ->OnEvent5(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBD)) ->OnEvent6(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBE))); llvm-svn: 189337
2013-08-27 19:09:05 +08:00
if (Precedence == prec::Conditional) {
Properly format nested conditional operators. Before: bool aaaaaa = aaaaaaaaaaaaa // ? aaaaaaaaaaaaaaa : bbbbbbbbbbbbbbb // ? ccccccccccccccc : ddddddddddddddd; After: bool aaaaaa = aaaaaaaaaaaaa // ? aaaaaaaaaaaaaaa : bbbbbbbbbbbbbbb // ? ccccccccccccccc : ddddddddddddddd; llvm-svn: 183007
2013-05-31 22:56:12 +08:00
parseConditionalExpr();
return;
}
clang-format: Fix indentation relative to unary expressions. This should be done, only if we are still in the unary expression's scope. Before: bool aaaa = !aaaaaaaa( // break aaaaaaaaaaa); *aaaaaa = aaaaaaa( // break aaaaaaaaaaaaaaaa); After: bool aaaa = !aaaaaaaa( // break aaaaaaaaaaa); // <- (unchanged) *aaaaaa = aaaaaaa( // break aaaaaaaaaaaaaaaa); // <- (no longer indented relative to "*") llvm-svn: 189108
2013-08-23 23:14:03 +08:00
// Parse unary operators, which all have a higher precedence than binary
// operators.
clang-format: Revamp builder-type call formatting. Previously builder-type calls were only correctly recognized in top-level calls. This fixes llvm.org/PR16981. Before: someobj->Add((new util::filetools::Handler(dir))->OnEvent1( NewPermanentCallback(this, &HandlerHolderClass::EventHandlerCBA)) ->OnEvent2(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBB)) ->OnEvent3(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBC)) ->OnEvent5(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBD)) ->OnEvent6(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBE))); After: someobj->Add((new util::filetools::Handler(dir)) ->OnEvent1(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBA)) ->OnEvent2(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBB)) ->OnEvent3(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBC)) ->OnEvent5(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBD)) ->OnEvent6(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBE))); llvm-svn: 189337
2013-08-27 19:09:05 +08:00
if (Precedence == PrecedenceUnaryOperator) {
clang-format: Fix indentation relative to unary expressions. This should be done, only if we are still in the unary expression's scope. Before: bool aaaa = !aaaaaaaa( // break aaaaaaaaaaa); *aaaaaa = aaaaaaa( // break aaaaaaaaaaaaaaaa); After: bool aaaa = !aaaaaaaa( // break aaaaaaaaaaa); // <- (unchanged) *aaaaaa = aaaaaaa( // break aaaaaaaaaaaaaaaa); // <- (no longer indented relative to "*") llvm-svn: 189108
2013-08-23 23:14:03 +08:00
parseUnaryOperator();
Implement a tiny expression parser to improve formatting decisions. With this patch, the formatter introduces 'fake' parenthesis according to the operator precedence of binary operators. Before: return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA || bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB || cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC || dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD; f(aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa); After: return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA || bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB || cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC || dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD; f(aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa); Future improvements: - Get rid of some of the hacky ways to nicely format certain constructs. - Merge this parser and the AnnotatingParser as we now have several parsers that analyze (), [], etc. llvm-svn: 174714
2013-02-08 23:28:42 +08:00
return;
clang-format: Fix indentation relative to unary expressions. This should be done, only if we are still in the unary expression's scope. Before: bool aaaa = !aaaaaaaa( // break aaaaaaaaaaa); *aaaaaa = aaaaaaa( // break aaaaaaaaaaaaaaaa); After: bool aaaa = !aaaaaaaa( // break aaaaaaaaaaa); // <- (unchanged) *aaaaaa = aaaaaaa( // break aaaaaaaaaaaaaaaa); // <- (no longer indented relative to "*") llvm-svn: 189108
2013-08-23 23:14:03 +08:00
}
Implement a tiny expression parser to improve formatting decisions. With this patch, the formatter introduces 'fake' parenthesis according to the operator precedence of binary operators. Before: return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA || bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB || cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC || dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD; f(aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa); After: return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA || bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB || cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC || dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD; f(aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa); Future improvements: - Get rid of some of the hacky ways to nicely format certain constructs. - Merge this parser and the AnnotatingParser as we now have several parsers that analyze (), [], etc. llvm-svn: 174714
2013-02-08 23:28:42 +08:00
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
FormatToken *Start = Current;
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
FormatToken *LatestOperator = nullptr;
clang-format: Add special case to reduce indentaiton in streams. This is similar to how we treat assignments and seems to be generally desirable. Before: llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa( aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa); After: llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa( aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa); llvm-svn: 206384
2014-04-16 20:26:54 +08:00
unsigned OperatorIndex = 0;
Implement a tiny expression parser to improve formatting decisions. With this patch, the formatter introduces 'fake' parenthesis according to the operator precedence of binary operators. Before: return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA || bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB || cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC || dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD; f(aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa); After: return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA || bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB || cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC || dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD; f(aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa); Future improvements: - Get rid of some of the hacky ways to nicely format certain constructs. - Merge this parser and the AnnotatingParser as we now have several parsers that analyze (), [], etc. llvm-svn: 174714
2013-02-08 23:28:42 +08:00
Better formatting of conditional expressions. In conditional expressions, if the condition is split over multiple lines, also break before both operands. This prevents formattings like: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ? b : c; Which are bad, because they suggestion incorrect operator precedence: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ? b : c); This lead to the discovery that the expression parser incorrectly handled conditional operators and that it could also handle semicolons (which in turn reduced the amount of special casing for for-loops). As a side-effect, we can now apply the bin-packing configuration to the sections of for-loops. llvm-svn: 175973
2013-02-24 05:01:55 +08:00
while (Current) {
Implement a tiny expression parser to improve formatting decisions. With this patch, the formatter introduces 'fake' parenthesis according to the operator precedence of binary operators. Before: return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA || bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB || cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC || dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD; f(aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa); After: return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA || bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB || cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC || dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD; f(aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa); Future improvements: - Get rid of some of the hacky ways to nicely format certain constructs. - Merge this parser and the AnnotatingParser as we now have several parsers that analyze (), [], etc. llvm-svn: 174714
2013-02-08 23:28:42 +08:00
// Consume operators with higher precedence.
Revamp indentation behavior for complex binary expressions. The idea is to indent according to operator precedence and pretty much identical to how stuff would be indented with parenthesis. Before: bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa > ccccccccccccccccccccccccccccccccccccccccc; After: bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa > ccccccccccccccccccccccccccccccccccccccccc; llvm-svn: 179049
2013-04-09 04:33:42 +08:00
parse(Precedence + 1);
Implement a tiny expression parser to improve formatting decisions. With this patch, the formatter introduces 'fake' parenthesis according to the operator precedence of binary operators. Before: return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA || bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB || cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC || dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD; f(aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa); After: return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA || bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB || cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC || dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD; f(aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa); Future improvements: - Get rid of some of the hacky ways to nicely format certain constructs. - Merge this parser and the AnnotatingParser as we now have several parsers that analyze (), [], etc. llvm-svn: 174714
2013-02-08 23:28:42 +08:00
clang-format: Fix indentation relative to unary expressions. This should be done, only if we are still in the unary expression's scope. Before: bool aaaa = !aaaaaaaa( // break aaaaaaaaaaa); *aaaaaa = aaaaaaa( // break aaaaaaaaaaaaaaaa); After: bool aaaa = !aaaaaaaa( // break aaaaaaaaaaa); // <- (unchanged) *aaaaaa = aaaaaaa( // break aaaaaaaaaaaaaaaa); // <- (no longer indented relative to "*") llvm-svn: 189108
2013-08-23 23:14:03 +08:00
int CurrentPrecedence = getCurrentPrecedence();
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Current && Current->is(TT_SelectorName) &&
clang-format: Fix various problems in formatting ObjC blocks. Among other things, this fixes llvm.org/PR15269. llvm-svn: 197900
2013-12-23 15:29:06 +08:00
Precedence == CurrentPrecedence) {
if (LatestOperator)
addFakeParenthesis(Start, prec::Level(Precedence));
clang-format: Fix indentation relative to unary expressions. This should be done, only if we are still in the unary expression's scope. Before: bool aaaa = !aaaaaaaa( // break aaaaaaaaaaa); *aaaaaa = aaaaaaa( // break aaaaaaaaaaaaaaaa); After: bool aaaa = !aaaaaaaa( // break aaaaaaaaaaa); // <- (unchanged) *aaaaaa = aaaaaaa( // break aaaaaaaaaaaaaaaa); // <- (no longer indented relative to "*") llvm-svn: 189108
2013-08-23 23:14:03 +08:00
Start = Current;
clang-format: Fix various problems in formatting ObjC blocks. Among other things, this fixes llvm.org/PR15269. llvm-svn: 197900
2013-12-23 15:29:06 +08:00
}
Better formatting of conditional expressions. In conditional expressions, if the condition is split over multiple lines, also break before both operands. This prevents formattings like: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ? b : c; Which are bad, because they suggestion incorrect operator precedence: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ? b : c); This lead to the discovery that the expression parser incorrectly handled conditional operators and that it could also handle semicolons (which in turn reduced the amount of special casing for for-loops). As a side-effect, we can now apply the bin-packing configuration to the sections of for-loops. llvm-svn: 175973
2013-02-24 05:01:55 +08:00
Implement a tiny expression parser to improve formatting decisions. With this patch, the formatter introduces 'fake' parenthesis according to the operator precedence of binary operators. Before: return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA || bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB || cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC || dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD; f(aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa); After: return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA || bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB || cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC || dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD; f(aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa); Future improvements: - Get rid of some of the hacky ways to nicely format certain constructs. - Merge this parser and the AnnotatingParser as we now have several parsers that analyze (), [], etc. llvm-svn: 174714
2013-02-08 23:28:42 +08:00
// At the end of the line or when an operator with higher precedence is
// found, insert fake parenthesis and return.
clang-format: [JS] Fix bugs in parsing and aligning template strings. llvm-svn: 294009
2017-02-03 22:32:38 +08:00
if (!Current ||
(Current->closesScope() &&
(Current->MatchingParen || Current->is(TT_TemplateString))) ||
clang-format: Support assignments as conditional operands. Before: return a != b // comment ? a : a = a != b // comment ? a = b : a; After: return a != b // comment ? a : a = a != b // comment ? a = b : a; llvm-svn: 221987
2014-11-14 21:03:40 +08:00
(CurrentPrecedence != -1 && CurrentPrecedence < Precedence) ||
(CurrentPrecedence == prec::Conditional &&
Precedence == prec::Assignment && Current->is(tok::colon))) {
clang-format: Fix expression parser not closing stuff at end of stmt. Uncovered by a Java test case: Before: public some.package.Type someFunction( // comment int parameter) {} After: public some.package.Type someFunction( // comment int parameter) {} llvm-svn: 223228
2014-12-03 21:20:49 +08:00
break;
Implement a tiny expression parser to improve formatting decisions. With this patch, the formatter introduces 'fake' parenthesis according to the operator precedence of binary operators. Before: return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA || bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB || cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC || dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD; f(aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa); After: return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA || bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB || cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC || dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD; f(aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa); Future improvements: - Get rid of some of the hacky ways to nicely format certain constructs. - Merge this parser and the AnnotatingParser as we now have several parsers that analyze (), [], etc. llvm-svn: 174714
2013-02-08 23:28:42 +08:00
}
// Consume scopes: (), [], <> and {}
Fix labels with trailing comments and cleanup. Before: class A { public : // test }; After: class A { public: // test }; Also remove duplicate methods calculating properties of AnnotatedTokens and make them members of AnnotatedTokens so that they are in a common place. llvm-svn: 179167
2013-04-10 17:49:49 +08:00
if (Current->opensScope()) {
clang-format: [JS] Properly set scopes inside template strings. Before: var f = `aaaaaaaaaaaaa:${aaaaaaa .aaaaa} aaaaaaaa aaaaaaaaaaaaa:${aaaaaaa.aaaaa} aaaaaaaa`; After: var f = `aaaaaaaaaaaaa:${aaaaaaa.aaaaa} aaaaaaaa aaaaaaaaaaaaa:${aaaaaaa.aaaaa} aaaaaaaa`; llvm-svn: 293622
2017-01-31 21:03:07 +08:00
// 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())) {
Implement a tiny expression parser to improve formatting decisions. With this patch, the formatter introduces 'fake' parenthesis according to the operator precedence of binary operators. Before: return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA || bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB || cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC || dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD; f(aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa); After: return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA || bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB || cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC || dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD; f(aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa); Future improvements: - Get rid of some of the hacky ways to nicely format certain constructs. - Merge this parser and the AnnotatingParser as we now have several parsers that analyze (), [], etc. llvm-svn: 174714
2013-02-08 23:28:42 +08:00
next();
parse();
}
next();
} else {
// Operator found.
clang-format: Add special case to reduce indentaiton in streams. This is similar to how we treat assignments and seems to be generally desirable. Before: llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa( aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa); After: llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa( aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa); llvm-svn: 206384
2014-04-16 20:26:54 +08:00
if (CurrentPrecedence == Precedence) {
clang-format: Improve line wrapping behavior in call sequences. r256750 has been leading to an undesired behavior: aaaaaaaaaa .aaaaaaaaaaaaaaaaaaaaaaaa.aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa); This change increases penalty for wrapping before member accesses that aren't calls. Thus, this is again formatted as (as it has been before r256750): aaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaa.aaaaaa( aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa); llvm-svn: 256830
2016-01-05 21:03:50 +08:00
if (LatestOperator)
LatestOperator->NextOperator = Current;
clang-format: Revamp builder-type call formatting. Previously builder-type calls were only correctly recognized in top-level calls. This fixes llvm.org/PR16981. Before: someobj->Add((new util::filetools::Handler(dir))->OnEvent1( NewPermanentCallback(this, &HandlerHolderClass::EventHandlerCBA)) ->OnEvent2(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBB)) ->OnEvent3(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBC)) ->OnEvent5(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBD)) ->OnEvent6(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBE))); After: someobj->Add((new util::filetools::Handler(dir)) ->OnEvent1(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBA)) ->OnEvent2(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBB)) ->OnEvent3(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBC)) ->OnEvent5(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBD)) ->OnEvent6(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBE))); llvm-svn: 189337
2013-08-27 19:09:05 +08:00
LatestOperator = Current;
clang-format: Add special case to reduce indentaiton in streams. This is similar to how we treat assignments and seems to be generally desirable. Before: llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa( aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa); After: llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa( aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa); llvm-svn: 206384
2014-04-16 20:26:54 +08:00
Current->OperatorIndex = OperatorIndex;
++OperatorIndex;
}
clang-format: Improve handling of comments in binary expressions. Before: b = a && // Comment b.c && d; After: b = a && // Comment b.c && d; This fixes llvm.org/PR21535. llvm-svn: 221727
2014-11-12 07:04:51 +08:00
next(/*SkipPastLeadingComments=*/Precedence > 0);
Implement a tiny expression parser to improve formatting decisions. With this patch, the formatter introduces 'fake' parenthesis according to the operator precedence of binary operators. Before: return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA || bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB || cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC || dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD; f(aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa); After: return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA || bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB || cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC || dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD; f(aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa); Future improvements: - Get rid of some of the hacky ways to nicely format certain constructs. - Merge this parser and the AnnotatingParser as we now have several parsers that analyze (), [], etc. llvm-svn: 174714
2013-02-08 23:28:42 +08:00
}
}
clang-format: Fix expression parser not closing stuff at end of stmt. Uncovered by a Java test case: Before: public some.package.Type someFunction( // comment int parameter) {} After: public some.package.Type someFunction( // comment int parameter) {} llvm-svn: 223228
2014-12-03 21:20:49 +08:00
if (LatestOperator && (Current || Precedence > 0)) {
clang-format: Improve line wrapping behavior in call sequences. r256750 has been leading to an undesired behavior: aaaaaaaaaa .aaaaaaaaaaaaaaaaaaaaaaaa.aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa); This change increases penalty for wrapping before member accesses that aren't calls. Thus, this is again formatted as (as it has been before r256750): aaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaa.aaaaaa( aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa); llvm-svn: 256830
2016-01-05 21:03:50 +08:00
// LatestOperator->LastOperator = true;
clang-format: Fix expression parser not closing stuff at end of stmt. Uncovered by a Java test case: Before: public some.package.Type someFunction( // comment int parameter) {} After: public some.package.Type someFunction( // comment int parameter) {} llvm-svn: 223228
2014-12-03 21:20:49 +08:00
if (Precedence == PrecedenceArrowAndPeriod) {
// Call expressions don't have a binary operator precedence.
addFakeParenthesis(Start, prec::Unknown);
} else {
addFakeParenthesis(Start, prec::Level(Precedence));
}
}
Implement a tiny expression parser to improve formatting decisions. With this patch, the formatter introduces 'fake' parenthesis according to the operator precedence of binary operators. Before: return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA || bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB || cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC || dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD; f(aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa); After: return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA || bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB || cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC || dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD; f(aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa); Future improvements: - Get rid of some of the hacky ways to nicely format certain constructs. - Merge this parser and the AnnotatingParser as we now have several parsers that analyze (), [], etc. llvm-svn: 174714
2013-02-08 23:28:42 +08:00
}
private:
Remove \brief commands from doxygen comments. This is similar to the LLVM change https://reviews.llvm.org/D46290. We've been running doxygen with the autobrief option for a couple of years now. This makes the \brief markers into our comments redundant. Since they are a visual distraction and we don't want to encourage more \brief markers in new code either, this patch removes them all. Patch produced by for i in $(git grep -l '\@brief'); do perl -pi -e 's/\@brief //g' $i & done for i in $(git grep -l '\\brief'); do perl -pi -e 's/\\brief //g' $i & done Differential Revision: https://reviews.llvm.org/D46320 llvm-svn: 331834
2018-05-09 09:00:01 +08:00
/// Gets the precedence (+1) of the given token for binary operators
clang-format: Fix indentation relative to unary expressions. This should be done, only if we are still in the unary expression's scope. Before: bool aaaa = !aaaaaaaa( // break aaaaaaaaaaa); *aaaaaa = aaaaaaa( // break aaaaaaaaaaaaaaaa); After: bool aaaa = !aaaaaaaa( // break aaaaaaaaaaa); // <- (unchanged) *aaaaaa = aaaaaaa( // break aaaaaaaaaaaaaaaa); // <- (no longer indented relative to "*") llvm-svn: 189108
2013-08-23 23:14:03 +08:00
/// and other tokens that we treat like binary operators.
int getCurrentPrecedence() {
if (Current) {
clang-format: [JS] Fix indentation in dict literals. Before: return { 'finish': // a }; After: return { 'finish': // a }; llvm-svn: 217235
2014-09-05 16:29:31 +08:00
const FormatToken *NextNonComment = Current->getNextNonComment();
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Current->is(TT_ConditionalExpr))
clang-format: Revamp builder-type call formatting. Previously builder-type calls were only correctly recognized in top-level calls. This fixes llvm.org/PR16981. Before: someobj->Add((new util::filetools::Handler(dir))->OnEvent1( NewPermanentCallback(this, &HandlerHolderClass::EventHandlerCBA)) ->OnEvent2(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBB)) ->OnEvent3(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBC)) ->OnEvent5(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBD)) ->OnEvent6(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBE))); After: someobj->Add((new util::filetools::Handler(dir)) ->OnEvent1(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBA)) ->OnEvent2(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBB)) ->OnEvent3(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBC)) ->OnEvent5(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBD)) ->OnEvent6(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBE))); llvm-svn: 189337
2013-08-27 19:09:05 +08:00
return prec::Conditional;
[clang-format] Fix parsing of msg{field}-style proto options Summary: This patch makes the `{` in `msg_field{field: OK}` in a proto option scope be treated as an assignment operator. Previosly the added test case was formatted as: ``` option (MyProto.options) = { field_a: OK field_b{field_c: OK} field_d: OKOKOK field_e: OK } ``` Reviewers: djasper Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D34749 llvm-svn: 306672
2017-06-29 21:30:41 +08:00
if (NextNonComment && Current->is(TT_SelectorName) &&
clang-format: [JS] wrap optional properties in type aliases. Summary: clang-format wraps object literal keys in an object literal if they are marked as `TT_SelectorName`s and/or the colon is marked as `TT_DictLiteral`. Previously, clang-format would accidentally work because colons in type aliases were marked as `TT_DictLiteral`. r310367 fixed this to assing `TT_JsTypeColon`, which broke wrapping in certain situations. However the root cause was that clang-format incorrectly didn't skip questionmarks when detecting selector name. This change fixes both locations to (1) assign `TT_SelectorName` and (2) treat `TT_JsTypeColon` like `TT_DictLiteral`. Previously: type X = { a: string, b?: string, }; Now: type X = { a: string, b?: string, }; Reviewers: djasper, sammccall Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D36684 llvm-svn: 310852
2017-08-15 00:09:08 +08:00
(NextNonComment->isOneOf(TT_DictLiteral, TT_JsTypeColon) ||
[clang-format] Support text proto messages Summary: This patch adds support for textual protocol buffer messages. Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek, mgorny Differential Revision: https://reviews.llvm.org/D34441 llvm-svn: 307029
2017-07-03 23:05:14 +08:00
((Style.Language == FormatStyle::LK_Proto ||
Style.Language == FormatStyle::LK_TextProto) &&
[clang-format] Fix parsing of msg{field}-style proto options Summary: This patch makes the `{` in `msg_field{field: OK}` in a proto option scope be treated as an assignment operator. Previosly the added test case was formatted as: ``` option (MyProto.options) = { field_a: OK field_b{field_c: OK} field_d: OKOKOK field_e: OK } ``` Reviewers: djasper Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D34749 llvm-svn: 306672
2017-06-29 21:30:41 +08:00
NextNonComment->is(tok::less))))
clang-format: [JS] Properly format object literals with shorthands. Before: return { a, b: 'b', c, }; After: return { a, b: 'b', c, }; llvm-svn: 296664
2017-03-02 03:47:28 +08:00
return prec::Assignment;
if (Current->is(TT_JsComputedPropertyName))
return prec::Assignment;
clang-format: [JS] Let fat arrows have 'Equality' precedence. This fixes a regression in literal formatting: Before: aaaaaaaaaaaaa = { aaaaaaaaaaaaaaaaaaaaaaaaaaaa: (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) => aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, }; After: var aaaaaaaaaaaaaaaaaaaa = { aaaaaaaaaaaaaaaaaaaaaaaaaaaa: (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) => aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, }; Also apply no-else-after-return policy. llvm-svn: 238942
2015-06-04 01:08:40 +08:00
if (Current->is(TT_LambdaArrow))
clang-format: [Java] Basic lambda support. llvm-svn: 222524
2014-11-21 20:14:12 +08:00
return prec::Comma;
clang-format: [JS] Let fat arrows have 'Equality' precedence. This fixes a regression in literal formatting: Before: aaaaaaaaaaaaa = { aaaaaaaaaaaaaaaaaaaaaaaaaaaa: (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) => aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, }; After: var aaaaaaaaaaaaaaaaaaaa = { aaaaaaaaaaaaaaaaaaaaaaaaaaaa: (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) => aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, }; Also apply no-else-after-return policy. llvm-svn: 238942
2015-06-04 01:08:40 +08:00
if (Current->is(TT_JsFatArrow))
clang-format: [JS] Let fat arrows have 'Assignment' precedence. This is a more correct representation than using "Equality" introduced in r238942 which was a quick fix to solve an actual regression. According to the typescript spec, arrows behave like "low-precedence" assignments. Before: var a = a.aaaaaaa((a: a) => aaaaaaaaaaaaaaaaaaaaa(bbbbbbbbb) && aaaaaaaaaaaaaaaaaaaaa(bbbbbbb)); After: var a = a.aaaaaaa((a: a) => aaaaaaaaaaaaaaaaaaaaa(bbbbbbbbb) && aaaaaaaaaaaaaaaaaaaaa(bbbbbbb)); llvm-svn: 239137
2015-06-05 16:25:37 +08:00
return prec::Assignment;
clang-format: [JS] Properly format object literals with shorthands. Before: return { a, b: 'b', c, }; After: return { a, b: 'b', c, }; llvm-svn: 296664
2017-03-02 03:47:28 +08:00
if (Current->isOneOf(tok::semi, TT_InlineASMColon, TT_SelectorName) ||
clang-format: [JS] Let fat arrows have 'Equality' precedence. This fixes a regression in literal formatting: Before: aaaaaaaaaaaaa = { aaaaaaaaaaaaaaaaaaaaaaaaaaaa: (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) => aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, }; After: var aaaaaaaaaaaaaaaaaaaa = { aaaaaaaaaaaaaaaaaaaaaaaaaaaa: (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) => aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, }; Also apply no-else-after-return policy. llvm-svn: 238942
2015-06-04 01:08:40 +08:00
(Current->is(tok::comment) && NextNonComment &&
NextNonComment->is(TT_SelectorName)))
clang-format: Revamp builder-type call formatting. Previously builder-type calls were only correctly recognized in top-level calls. This fixes llvm.org/PR16981. Before: someobj->Add((new util::filetools::Handler(dir))->OnEvent1( NewPermanentCallback(this, &HandlerHolderClass::EventHandlerCBA)) ->OnEvent2(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBB)) ->OnEvent3(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBC)) ->OnEvent5(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBD)) ->OnEvent6(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBE))); After: someobj->Add((new util::filetools::Handler(dir)) ->OnEvent1(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBA)) ->OnEvent2(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBB)) ->OnEvent3(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBC)) ->OnEvent5(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBD)) ->OnEvent6(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBE))); llvm-svn: 189337
2013-08-27 19:09:05 +08:00
return 0;
clang-format: [JS] Let fat arrows have 'Equality' precedence. This fixes a regression in literal formatting: Before: aaaaaaaaaaaaa = { aaaaaaaaaaaaaaaaaaaaaaaaaaaa: (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) => aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, }; After: var aaaaaaaaaaaaaaaaaaaa = { aaaaaaaaaaaaaaaaaaaaaaaaaaaa: (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) => aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, }; Also apply no-else-after-return policy. llvm-svn: 238942
2015-06-04 01:08:40 +08:00
if (Current->is(TT_RangeBasedForLoopColon))
clang-format: Fix range-based for-loop formatting. Before: for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa : aaaaaaaaaaaa.aaaaaaaaaaaa() .aaaaaaaaa() .a()) { } After: for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa : aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) { } llvm-svn: 200968
2014-02-07 18:09:46 +08:00
return prec::Comma;
clang-format: [Java/JS] Properly support instanceof and its precedence. llvm-svn: 241337
2015-07-03 18:12:53 +08:00
if ((Style.Language == FormatStyle::LK_Java ||
Style.Language == FormatStyle::LK_JavaScript) &&
Current->is(Keywords.kw_instanceof))
return prec::Relational;
clang-format: [JS] Treat "in" as a proper operator. llvm-svn: 259350
2016-02-01 19:20:47 +08:00
if (Style.Language == FormatStyle::LK_JavaScript &&
clang-format: [JS/TS] Properly understand cast expressions. Many things were wrong: - We didn't always allow wrapping after "as", which can be necessary. - We used to Undestand the identifier after "as" as a start of a name. - We didn't properly parse the structure of the expression with "as" having the precedence of relational operators llvm-svn: 296659
2017-03-02 03:26:12 +08:00
Current->isOneOf(Keywords.kw_in, Keywords.kw_as))
clang-format: [JS] Treat "in" as a proper operator. llvm-svn: 259350
2016-02-01 19:20:47 +08:00
return prec::Relational;
clang-format: [JS] Let fat arrows have 'Equality' precedence. This fixes a regression in literal formatting: Before: aaaaaaaaaaaaa = { aaaaaaaaaaaaaaaaaaaaaaaaaaaa: (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) => aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, }; After: var aaaaaaaaaaaaaaaaaaaa = { aaaaaaaaaaaaaaaaaaaaaaaaaaaa: (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) => aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, }; Also apply no-else-after-return policy. llvm-svn: 238942
2015-06-04 01:08:40 +08:00
if (Current->is(TT_BinaryOperator) || Current->is(tok::comma))
clang-format: Revamp builder-type call formatting. Previously builder-type calls were only correctly recognized in top-level calls. This fixes llvm.org/PR16981. Before: someobj->Add((new util::filetools::Handler(dir))->OnEvent1( NewPermanentCallback(this, &HandlerHolderClass::EventHandlerCBA)) ->OnEvent2(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBB)) ->OnEvent3(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBC)) ->OnEvent5(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBD)) ->OnEvent6(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBE))); After: someobj->Add((new util::filetools::Handler(dir)) ->OnEvent1(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBA)) ->OnEvent2(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBB)) ->OnEvent3(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBC)) ->OnEvent5(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBD)) ->OnEvent6(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBE))); llvm-svn: 189337
2013-08-27 19:09:05 +08:00
return Current->getPrecedence();
clang-format: [JS] Let fat arrows have 'Equality' precedence. This fixes a regression in literal formatting: Before: aaaaaaaaaaaaa = { aaaaaaaaaaaaaaaaaaaaaaaaaaaa: (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) => aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, }; After: var aaaaaaaaaaaaaaaaaaaa = { aaaaaaaaaaaaaaaaaaaaaaaaaaaa: (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) => aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, }; Also apply no-else-after-return policy. llvm-svn: 238942
2015-06-04 01:08:40 +08:00
if (Current->isOneOf(tok::period, tok::arrow))
clang-format: Revamp builder-type call formatting. Previously builder-type calls were only correctly recognized in top-level calls. This fixes llvm.org/PR16981. Before: someobj->Add((new util::filetools::Handler(dir))->OnEvent1( NewPermanentCallback(this, &HandlerHolderClass::EventHandlerCBA)) ->OnEvent2(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBB)) ->OnEvent3(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBC)) ->OnEvent5(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBD)) ->OnEvent6(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBE))); After: someobj->Add((new util::filetools::Handler(dir)) ->OnEvent1(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBA)) ->OnEvent2(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBB)) ->OnEvent3(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBC)) ->OnEvent5(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBD)) ->OnEvent6(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBE))); llvm-svn: 189337
2013-08-27 19:09:05 +08:00
return PrecedenceArrowAndPeriod;
clang-format: [JS] Support annotated classes. llvm-svn: 272654
2016-06-14 19:28:02 +08:00
if ((Style.Language == FormatStyle::LK_Java ||
Style.Language == FormatStyle::LK_JavaScript) &&
clang-format: [JS] Let fat arrows have 'Equality' precedence. This fixes a regression in literal formatting: Before: aaaaaaaaaaaaa = { aaaaaaaaaaaaaaaaaaaaaaaaaaaa: (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) => aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, }; After: var aaaaaaaaaaaaaaaaaaaa = { aaaaaaaaaaaaaaaaaaaaaaaaaaaa: (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) => aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, }; Also apply no-else-after-return policy. llvm-svn: 238942
2015-06-04 01:08:40 +08:00
Current->isOneOf(Keywords.kw_extends, Keywords.kw_implements,
Keywords.kw_throws))
clang-format: [Java] Don't break after extends/implements. Before: abstract class SomeClass extends SomeOtherClass implements SomeInterface {} After: abstract class SomeClass extends SomeOtherClass implements SomeInterface {} llvm-svn: 221103
2014-11-03 03:16:41 +08:00
return 0;
clang-format: Fix indentation relative to unary expressions. This should be done, only if we are still in the unary expression's scope. Before: bool aaaa = !aaaaaaaa( // break aaaaaaaaaaa); *aaaaaa = aaaaaaa( // break aaaaaaaaaaaaaaaa); After: bool aaaa = !aaaaaaaa( // break aaaaaaaaaaa); // <- (unchanged) *aaaaaa = aaaaaaa( // break aaaaaaaaaaaaaaaa); // <- (no longer indented relative to "*") llvm-svn: 189108
2013-08-23 23:14:03 +08:00
}
clang-format: Revamp builder-type call formatting. Previously builder-type calls were only correctly recognized in top-level calls. This fixes llvm.org/PR16981. Before: someobj->Add((new util::filetools::Handler(dir))->OnEvent1( NewPermanentCallback(this, &HandlerHolderClass::EventHandlerCBA)) ->OnEvent2(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBB)) ->OnEvent3(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBC)) ->OnEvent5(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBD)) ->OnEvent6(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBE))); After: someobj->Add((new util::filetools::Handler(dir)) ->OnEvent1(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBA)) ->OnEvent2(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBB)) ->OnEvent3(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBC)) ->OnEvent5(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBD)) ->OnEvent6(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBE))); llvm-svn: 189337
2013-08-27 19:09:05 +08:00
return -1;
clang-format: Fix indentation relative to unary expressions. This should be done, only if we are still in the unary expression's scope. Before: bool aaaa = !aaaaaaaa( // break aaaaaaaaaaa); *aaaaaa = aaaaaaa( // break aaaaaaaaaaaaaaaa); After: bool aaaa = !aaaaaaaa( // break aaaaaaaaaaa); // <- (unchanged) *aaaaaa = aaaaaaa( // break aaaaaaaaaaaaaaaa); // <- (no longer indented relative to "*") llvm-svn: 189108
2013-08-23 23:14:03 +08:00
}
Properly format nested conditional operators. Before: bool aaaaaa = aaaaaaaaaaaaa // ? aaaaaaaaaaaaaaa : bbbbbbbbbbbbbbb // ? ccccccccccccccc : ddddddddddddddd; After: bool aaaaaa = aaaaaaaaaaaaa // ? aaaaaaaaaaaaaaa : bbbbbbbbbbbbbbb // ? ccccccccccccccc : ddddddddddddddd; llvm-svn: 183007
2013-05-31 22:56:12 +08:00
void addFakeParenthesis(FormatToken *Start, prec::Level Precedence) {
Start->FakeLParens.push_back(Precedence);
clang-format: Fix regression introduced by r189337. Before: if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa( aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) ... After: if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa( aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) ... Also precompute startsBinaryExpression() to improve performance. llvm-svn: 190124
2013-09-06 16:08:14 +08:00
if (Precedence > prec::Unknown)
Start->StartsBinaryExpression = true;
if (Current) {
clang-format: Improve indentation of comments in expressions. Before: int i = (a) // comment + b; return aaaa == bbbb // comment ? aaaa : bbbb; After: int i = (a) // comment + b; return aaaa == bbbb // comment ? aaaa : bbbb; llvm-svn: 221985
2014-11-14 20:31:14 +08:00
FormatToken *Previous = Current->Previous;
clang-format: Fix fake parentheses placement with comments. Before: return (a > b // comment1 // comment2 || c); After: return (a > b // comment1 // comment2 || c); llvm-svn: 223234
2014-12-03 22:02:59 +08:00
while (Previous->is(tok::comment) && Previous->Previous)
clang-format: Improve indentation of comments in expressions. Before: int i = (a) // comment + b; return aaaa == bbbb // comment ? aaaa : bbbb; After: int i = (a) // comment + b; return aaaa == bbbb // comment ? aaaa : bbbb; llvm-svn: 221985
2014-11-14 20:31:14 +08:00
Previous = Previous->Previous;
++Previous->FakeRParens;
clang-format: Fix regression introduced by r189337. Before: if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa( aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) ... After: if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa( aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) ... Also precompute startsBinaryExpression() to improve performance. llvm-svn: 190124
2013-09-06 16:08:14 +08:00
if (Precedence > prec::Unknown)
clang-format: Improve indentation of comments in expressions. Before: int i = (a) // comment + b; return aaaa == bbbb // comment ? aaaa : bbbb; After: int i = (a) // comment + b; return aaaa == bbbb // comment ? aaaa : bbbb; llvm-svn: 221985
2014-11-14 20:31:14 +08:00
Previous->EndsBinaryExpression = true;
clang-format: Fix regression introduced by r189337. Before: if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa( aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) ... After: if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa( aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) ... Also precompute startsBinaryExpression() to improve performance. llvm-svn: 190124
2013-09-06 16:08:14 +08:00
}
Properly format nested conditional operators. Before: bool aaaaaa = aaaaaaaaaaaaa // ? aaaaaaaaaaaaaaa : bbbbbbbbbbbbbbb // ? ccccccccccccccc : ddddddddddddddd; After: bool aaaaaa = aaaaaaaaaaaaa // ? aaaaaaaaaaaaaaa : bbbbbbbbbbbbbbb // ? ccccccccccccccc : ddddddddddddddd; llvm-svn: 183007
2013-05-31 22:56:12 +08:00
}
Remove \brief commands from doxygen comments. This is similar to the LLVM change https://reviews.llvm.org/D46290. We've been running doxygen with the autobrief option for a couple of years now. This makes the \brief markers into our comments redundant. Since they are a visual distraction and we don't want to encourage more \brief markers in new code either, this patch removes them all. Patch produced by for i in $(git grep -l '\@brief'); do perl -pi -e 's/\@brief //g' $i & done for i in $(git grep -l '\\brief'); do perl -pi -e 's/\\brief //g' $i & done Differential Revision: https://reviews.llvm.org/D46320 llvm-svn: 331834
2018-05-09 09:00:01 +08:00
/// Parse unary operator expressions and surround them with fake
clang-format: Fix indentation relative to unary expressions. This should be done, only if we are still in the unary expression's scope. Before: bool aaaa = !aaaaaaaa( // break aaaaaaaaaaa); *aaaaaa = aaaaaaa( // break aaaaaaaaaaaaaaaa); After: bool aaaa = !aaaaaaaa( // break aaaaaaaaaaa); // <- (unchanged) *aaaaaa = aaaaaaa( // break aaaaaaaaaaaaaaaa); // <- (no longer indented relative to "*") llvm-svn: 189108
2013-08-23 23:14:03 +08:00
/// parentheses if appropriate.
void parseUnaryOperator() {
[clang-format] Make parseUnaryOperator non-recursive, NFCI Summary: This patch makes the implementation of parseUnaryOperator non-recursive. We had a problem with a file starting with tens of thousands of +'es and -'es which caused clang-format to stack overflow. Reviewers: bkramer Reviewed By: bkramer Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D39498 llvm-svn: 317113
2017-11-02 02:20:41 +08:00
llvm::SmallVector<FormatToken *, 2> Tokens;
while (Current && Current->is(TT_UnaryOperator)) {
Tokens.push_back(Current);
next();
clang-format: Revamp builder-type call formatting. Previously builder-type calls were only correctly recognized in top-level calls. This fixes llvm.org/PR16981. Before: someobj->Add((new util::filetools::Handler(dir))->OnEvent1( NewPermanentCallback(this, &HandlerHolderClass::EventHandlerCBA)) ->OnEvent2(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBB)) ->OnEvent3(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBC)) ->OnEvent5(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBD)) ->OnEvent6(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBE))); After: someobj->Add((new util::filetools::Handler(dir)) ->OnEvent1(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBA)) ->OnEvent2(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBB)) ->OnEvent3(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBC)) ->OnEvent5(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBD)) ->OnEvent6(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBE))); llvm-svn: 189337
2013-08-27 19:09:05 +08:00
}
[clang-format] Make parseUnaryOperator non-recursive, NFCI Summary: This patch makes the implementation of parseUnaryOperator non-recursive. We had a problem with a file starting with tens of thousands of +'es and -'es which caused clang-format to stack overflow. Reviewers: bkramer Reviewed By: bkramer Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D39498 llvm-svn: 317113
2017-11-02 02:20:41 +08:00
parse(PrecedenceArrowAndPeriod);
for (FormatToken *Token : llvm::reverse(Tokens))
// The actual precedence doesn't matter.
addFakeParenthesis(Token, prec::Unknown);
clang-format: Fix indentation relative to unary expressions. This should be done, only if we are still in the unary expression's scope. Before: bool aaaa = !aaaaaaaa( // break aaaaaaaaaaa); *aaaaaa = aaaaaaa( // break aaaaaaaaaaaaaaaa); After: bool aaaa = !aaaaaaaa( // break aaaaaaaaaaa); // <- (unchanged) *aaaaaa = aaaaaaa( // break aaaaaaaaaaaaaaaa); // <- (no longer indented relative to "*") llvm-svn: 189108
2013-08-23 23:14:03 +08:00
}
Properly format nested conditional operators. Before: bool aaaaaa = aaaaaaaaaaaaa // ? aaaaaaaaaaaaaaa : bbbbbbbbbbbbbbb // ? ccccccccccccccc : ddddddddddddddd; After: bool aaaaaa = aaaaaaaaaaaaa // ? aaaaaaaaaaaaaaa : bbbbbbbbbbbbbbb // ? ccccccccccccccc : ddddddddddddddd; llvm-svn: 183007
2013-05-31 22:56:12 +08:00
void parseConditionalExpr() {
clang-format: Fix behavior with comments before conditional expressions Before: SomeFunction(aaaaaaaaaaaaaaaaa, // comment. ccccccccccccccccc ? aaaaaaaaaaaaaaaaaaaa : bbbbbbbbbbbbbbbbbbbb); After: SomeFunction(aaaaaaaaaaaaaaaaa, // comment. ccccccccccccccccc ? aaaaaaaaaaaaaaaaaaaa : bbbbbbbbbbbbbbbbbbbb); llvm-svn: 219921
2014-10-16 17:10:11 +08:00
while (Current && Current->isTrailingComment()) {
next();
}
Properly format nested conditional operators. Before: bool aaaaaa = aaaaaaaaaaaaa // ? aaaaaaaaaaaaaaa : bbbbbbbbbbbbbbb // ? ccccccccccccccc : ddddddddddddddd; After: bool aaaaaa = aaaaaaaaaaaaa // ? aaaaaaaaaaaaaaa : bbbbbbbbbbbbbbb // ? ccccccccccccccc : ddddddddddddddd; llvm-svn: 183007
2013-05-31 22:56:12 +08:00
FormatToken *Start = Current;
clang-format: Revamp builder-type call formatting. Previously builder-type calls were only correctly recognized in top-level calls. This fixes llvm.org/PR16981. Before: someobj->Add((new util::filetools::Handler(dir))->OnEvent1( NewPermanentCallback(this, &HandlerHolderClass::EventHandlerCBA)) ->OnEvent2(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBB)) ->OnEvent3(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBC)) ->OnEvent5(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBD)) ->OnEvent6(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBE))); After: someobj->Add((new util::filetools::Handler(dir)) ->OnEvent1(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBA)) ->OnEvent2(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBB)) ->OnEvent3(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBC)) ->OnEvent5(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBD)) ->OnEvent6(NewPermanentCallback( this, &HandlerHolderClass::EventHandlerCBE))); llvm-svn: 189337
2013-08-27 19:09:05 +08:00
parse(prec::LogicalOr);
Properly format nested conditional operators. Before: bool aaaaaa = aaaaaaaaaaaaa // ? aaaaaaaaaaaaaaa : bbbbbbbbbbbbbbb // ? ccccccccccccccc : ddddddddddddddd; After: bool aaaaaa = aaaaaaaaaaaaa // ? aaaaaaaaaaaaaaa : bbbbbbbbbbbbbbb // ? ccccccccccccccc : ddddddddddddddd; llvm-svn: 183007
2013-05-31 22:56:12 +08:00
if (!Current || !Current->is(tok::question))
return;
next();
clang-format: Support assignments as conditional operands. Before: return a != b // comment ? a : a = a != b // comment ? a = b : a; After: return a != b // comment ? a : a = a != b // comment ? a = b : a; llvm-svn: 221987
2014-11-14 21:03:40 +08:00
parse(prec::Assignment);
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (!Current || Current->isNot(TT_ConditionalExpr))
Properly format nested conditional operators. Before: bool aaaaaa = aaaaaaaaaaaaa // ? aaaaaaaaaaaaaaa : bbbbbbbbbbbbbbb // ? ccccccccccccccc : ddddddddddddddd; After: bool aaaaaa = aaaaaaaaaaaaa // ? aaaaaaaaaaaaaaa : bbbbbbbbbbbbbbb // ? ccccccccccccccc : ddddddddddddddd; llvm-svn: 183007
2013-05-31 22:56:12 +08:00
return;
next();
clang-format: Support assignments as conditional operands. Before: return a != b // comment ? a : a = a != b // comment ? a = b : a; After: return a != b // comment ? a : a = a != b // comment ? a = b : a; llvm-svn: 221987
2014-11-14 21:03:40 +08:00
parse(prec::Assignment);
Properly format nested conditional operators. Before: bool aaaaaa = aaaaaaaaaaaaa // ? aaaaaaaaaaaaaaa : bbbbbbbbbbbbbbb // ? ccccccccccccccc : ddddddddddddddd; After: bool aaaaaa = aaaaaaaaaaaaa // ? aaaaaaaaaaaaaaa : bbbbbbbbbbbbbbb // ? ccccccccccccccc : ddddddddddddddd; llvm-svn: 183007
2013-05-31 22:56:12 +08:00
addFakeParenthesis(Start, prec::Conditional);
}
clang-format: [JS] Support comments in dict literals. Before: var stuff = { // comment for update update : false, // comment for update modules : false, // comment for update tasks : false }; After: var stuff = { // comment for update update : false, // comment for update modules : false, // comment for update tasks : false }; llvm-svn: 217157
2014-09-04 22:58:30 +08:00
void next(bool SkipPastLeadingComments = true) {
Fix a problem in ExpressionParser leading to trailing comments affecting indentation of an expression after a line break. Summary: E.g. the second line in return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + b; // is indented 4 characters more than in return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + b; Reviewers: klimek Reviewed By: klimek CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D984 llvm-svn: 184078
2013-06-17 21:19:53 +08:00
if (Current)
Current = Current->Next;
clang-format: [JS] Support comments in dict literals. Before: var stuff = { // comment for update update : false, // comment for update modules : false, // comment for update tasks : false }; After: var stuff = { // comment for update update : false, // comment for update modules : false, // comment for update tasks : false }; llvm-svn: 217157
2014-09-04 22:58:30 +08:00
while (Current &&
(Current->NewlinesBefore == 0 || SkipPastLeadingComments) &&
Current->isTrailingComment())
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
Current = Current->Next;
Implement a tiny expression parser to improve formatting decisions. With this patch, the formatter introduces 'fake' parenthesis according to the operator precedence of binary operators. Before: return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA || bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB || cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC || dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD; f(aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa); After: return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA || bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB || cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC || dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD; f(aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa); Future improvements: - Get rid of some of the hacky ways to nicely format certain constructs. - Merge this parser and the AnnotatingParser as we now have several parsers that analyze (), [], etc. llvm-svn: 174714
2013-02-08 23:28:42 +08:00
}
clang-format: [Java] Don't break after extends/implements. Before: abstract class SomeClass extends SomeOtherClass implements SomeInterface {} After: abstract class SomeClass extends SomeOtherClass implements SomeInterface {} llvm-svn: 221103
2014-11-03 03:16:41 +08:00
const FormatStyle &Style;
clang-format: Use identifier table for keywords in other languages. Slightly easier to write, more efficient and prevents bugs by misspelling them. No functional changes intended. llvm-svn: 221259
2014-11-04 20:41:02 +08:00
const AdditionalKeywords &Keywords;
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
FormatToken *Current;
Implement a tiny expression parser to improve formatting decisions. With this patch, the formatter introduces 'fake' parenthesis according to the operator precedence of binary operators. Before: return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA || bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB || cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC || dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD; f(aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa); After: return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA || bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB || cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC || dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD; f(aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa); Future improvements: - Get rid of some of the hacky ways to nicely format certain constructs. - Merge this parser and the AnnotatingParser as we now have several parsers that analyze (), [], etc. llvm-svn: 174714
2013-02-08 23:28:42 +08:00
};
Put helper classes in an anonymous namespace. llvm-svn: 185301
2013-07-01 12:03:19 +08:00
} // end anonymous namespace
clang-format: [Java] Support formatting qualified annotations. llvm-svn: 225559
2015-01-10 07:25:06 +08:00
void TokenAnnotator::setCommentLineLevels(
SmallVectorImpl<AnnotatedLine *> &Lines) {
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
const AnnotatedLine *NextNonCommentLine = nullptr;
clang-format: Allow line merging and partial formatting of nested blocks Before, clang-format would always format entire nested blocks, which can be unwanted e.g. for long DEBUG({...}) statements. Also clang-format would not allow to merge lines in nested blocks (e.g. to put "if (a) return;" on one line in Google style). This is the first step of several refactorings mostly focussing on the additional functionality (by reusing the "format many lines" code to format the children of a nested block). The next steps are: * Pull out the line merging into its own class. * Seperate the formatting of many lines from the formatting of a single line (and the analysis of the solution space). llvm-svn: 194090
2013-11-06 03:10:03 +08:00
for (SmallVectorImpl<AnnotatedLine *>::reverse_iterator I = Lines.rbegin(),
E = Lines.rend();
I != E; ++I) {
[clang-format] Keep level of comment before an empty line Summary: This patch fixes bug https://bugs.llvm.org/show_bug.cgi?id=3313: a comment line was aligned with the next #ifdef even in the presence of an empty line between them. Reviewers: djasper, klimek Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D35296 llvm-svn: 307795
2017-07-12 23:21:43 +08:00
bool CommentLine = true;
[clang-format] Implement comment reflowing. Summary: This presents a version of the comment reflowing with less mutable state inside the comment breakable token subclasses. The state has been pushed into the driving breakProtrudingToken method. For this, the API of BreakableToken is enriched by the methods getSplitBefore and getLineLengthAfterSplitBefore. Reviewers: klimek Reviewed By: klimek Subscribers: djasper, klimek, mgorny, cfe-commits, ioeric Differential Revision: https://reviews.llvm.org/D28764 llvm-svn: 293055
2017-01-25 21:58:58 +08:00
for (const FormatToken *Tok = (*I)->First; Tok; Tok = Tok->Next) {
if (!Tok->is(tok::comment)) {
CommentLine = false;
break;
}
}
[clang-format] Keep level of comment before an empty line Summary: This patch fixes bug https://bugs.llvm.org/show_bug.cgi?id=3313: a comment line was aligned with the next #ifdef even in the presence of an empty line between them. Reviewers: djasper, klimek Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D35296 llvm-svn: 307795
2017-07-12 23:21:43 +08:00
[clang-format] Align preprocessor comments with # Summary: r312125, which introduced preprocessor indentation, shipped with a known issue where "indentation of comments immediately before indented preprocessor lines is toggled on each run". For example these two forms toggle: #ifndef HEADER_H #define HEADER_H #if 1 // comment # define A 0 #endif #endif #ifndef HEADER_H #define HEADER_H #if 1 // comment # define A 0 #endif #endif This happens because we check vertical alignment against the '#' yet indent to the level of the 'define'. This patch resolves this issue by aligning against the '#'. Reviewers: krasimir, klimek, djasper Reviewed By: krasimir Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D42408 llvm-svn: 323904
2018-02-01 04:05:50 +08:00
// 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 ==
(*I)->First->OriginalColumn) {
// Align comments for preprocessor lines with the # in column 0.
// Otherwise, align with the next line.
(*I)->Level = (NextNonCommentLine->Type == LT_PreprocessorDirective ||
NextNonCommentLine->Type == LT_ImportStatement)
? 0
: NextNonCommentLine->Level;
[clang-format] Keep level of comment before an empty line Summary: This patch fixes bug https://bugs.llvm.org/show_bug.cgi?id=3313: a comment line was aligned with the next #ifdef even in the presence of an empty line between them. Reviewers: djasper, klimek Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D35296 llvm-svn: 307795
2017-07-12 23:21:43 +08:00
} else {
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
NextNonCommentLine = (*I)->First->isNot(tok::r_brace) ? (*I) : nullptr;
[clang-format] Keep level of comment before an empty line Summary: This patch fixes bug https://bugs.llvm.org/show_bug.cgi?id=3313: a comment line was aligned with the next #ifdef even in the presence of an empty line between them. Reviewers: djasper, klimek Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D35296 llvm-svn: 307795
2017-07-12 23:21:43 +08:00
}
clang-format: Allow line merging and partial formatting of nested blocks Before, clang-format would always format entire nested blocks, which can be unwanted e.g. for long DEBUG({...}) statements. Also clang-format would not allow to merge lines in nested blocks (e.g. to put "if (a) return;" on one line in Google style). This is the first step of several refactorings mostly focussing on the additional functionality (by reusing the "format many lines" code to format the children of a nested block). The next steps are: * Pull out the line merging into its own class. * Seperate the formatting of many lines from the formatting of a single line (and the analysis of the solution space). llvm-svn: 194090
2013-11-06 03:10:03 +08:00
setCommentLineLevels((*I)->Children);
clang-format: Fix comment formatting bugs in nested blocks. This fixes two issues: 1) The indent of a line comment was not adapted to the subsequent statement as it would be outside of a nested block. 2) A missing DryRun flag caused actualy breaks to be inserted in overly long comments while trying to come up with the best line breaking decisions. llvm-svn: 190123
2013-09-06 15:54:20 +08:00
}
}
Skip over AnnotatedLines with >50 levels of nesting; don't format them. Reasoning: - ExpressionParser uses a lot of stack for these, bad in some environments. - Our formatting algorithm is N^3 and gets really slow. - The resulting formatting is unlikely to be any good. - This is probably generated code we're formatting by accident. We treat these as unparseable, and signal incomplete formatting. 50 is an arbitrary number, I've only seen real problems from ~150 levels. Patch by Sam McCall. Thank you. llvm-svn: 285570
2016-10-31 21:23:00 +08:00
static unsigned maxNestingDepth(const AnnotatedLine &Line) {
unsigned Result = 0;
clang-format clang-format. llvm-svn: 313744
2017-09-20 17:51:03 +08:00
for (const auto *Tok = Line.First; Tok != nullptr; Tok = Tok->Next)
Skip over AnnotatedLines with >50 levels of nesting; don't format them. Reasoning: - ExpressionParser uses a lot of stack for these, bad in some environments. - Our formatting algorithm is N^3 and gets really slow. - The resulting formatting is unlikely to be any good. - This is probably generated code we're formatting by accident. We treat these as unparseable, and signal incomplete formatting. 50 is an arbitrary number, I've only seen real problems from ~150 levels. Patch by Sam McCall. Thank you. llvm-svn: 285570
2016-10-31 21:23:00 +08:00
Result = std::max(Result, Tok->NestingLevel);
return Result;
}
Optionally derive formatting information from the input file. With this patch, clang-format can analyze the input file for two properties: 1. Is "int *a" or "int* a" more common. 2. Are non-C++03 constructs used, e.g. A<A<A>>. With Google-style, clang-format will now use the more common style for (1) and format C++03 compatible, unless it finds C++11 constructs in the input. llvm-svn: 174504
2013-02-06 22:22:40 +08:00
void TokenAnnotator::annotate(AnnotatedLine &Line) {
clang-format: Fix comment formatting bugs in nested blocks. This fixes two issues: 1) The indent of a line comment was not adapted to the subsequent statement as it would be outside of a nested block. 2) A missing DryRun flag caused actualy breaks to be inserted in overly long comments while trying to come up with the best line breaking decisions. llvm-svn: 190123
2013-09-06 15:54:20 +08:00
for (SmallVectorImpl<AnnotatedLine *>::iterator I = Line.Children.begin(),
E = Line.Children.end();
clang-format: Enable formatting of nested blocks. Among other things, this enables (better) formatting lambdas and constructs like: MACRO({ long_statement(); long_statement_2(); }, { long_statement(); long_statement_2(); }, { short_statement(); }, ""); This fixes llvm.org/PR15381. llvm-svn: 190038
2013-09-05 17:29:45 +08:00
I != E; ++I) {
annotate(**I);
}
clang-format: Use identifier table for keywords in other languages. Slightly easier to write, more efficient and prevents bugs by misspelling them. No functional changes intended. llvm-svn: 221259
2014-11-04 20:41:02 +08:00
AnnotatingParser Parser(Style, Line, Keywords);
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
Line.Type = Parser.parseLine();
Skip over AnnotatedLines with >50 levels of nesting; don't format them. Reasoning: - ExpressionParser uses a lot of stack for these, bad in some environments. - Our formatting algorithm is N^3 and gets really slow. - The resulting formatting is unlikely to be any good. - This is probably generated code we're formatting by accident. We treat these as unparseable, and signal incomplete formatting. 50 is an arbitrary number, I've only seen real problems from ~150 levels. Patch by Sam McCall. Thank you. llvm-svn: 285570
2016-10-31 21:23:00 +08:00
// 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;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
if (Line.Type == LT_Invalid)
return;
clang-format: Use identifier table for keywords in other languages. Slightly easier to write, more efficient and prevents bugs by misspelling them. No functional changes intended. llvm-svn: 221259
2014-11-04 20:41:02 +08:00
ExpressionParser ExprParser(Style, Keywords, Line);
Implement a tiny expression parser to improve formatting decisions. With this patch, the formatter introduces 'fake' parenthesis according to the operator precedence of binary operators. Before: return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA || bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB || cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC || dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD; f(aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa); After: return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA || bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB || cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC || dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD; f(aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaa); Future improvements: - Get rid of some of the hacky ways to nicely format certain constructs. - Merge this parser and the AnnotatingParser as we now have several parsers that analyze (), [], etc. llvm-svn: 174714
2013-02-08 23:28:42 +08:00
ExprParser.parse();
clang-format: NFC. Add a function to test whether an annotated line starts with a given sequence of tokens. Only the one-token version is used yet, but other usages are coming up momentarily. llvm-svn: 239892
2015-06-17 17:43:56 +08:00
if (Line.startsWith(TT_ObjCMethodSpecifier))
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
Line.Type = LT_ObjCMethodDecl;
clang-format: NFC. Add a function to test whether an annotated line starts with a given sequence of tokens. Only the one-token version is used yet, but other usages are coming up momentarily. llvm-svn: 239892
2015-06-17 17:43:56 +08:00
else if (Line.startsWith(TT_ObjCDecl))
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
Line.Type = LT_ObjCDecl;
clang-format: NFC. Add a function to test whether an annotated line starts with a given sequence of tokens. Only the one-token version is used yet, but other usages are coming up momentarily. llvm-svn: 239892
2015-06-17 17:43:56 +08:00
else if (Line.startsWith(TT_ObjCProperty))
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
Line.Type = LT_ObjCProperty;
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
Line.First->SpacesRequiredBefore = 1;
Line.First->CanBreakBefore = Line.First->MustBreakBefore;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
}
clang-format: Revamp function declaration/definition indentation. Key changes: - Correctly (well ...) distinguish function declarations and variable declarations with ()-initialization. - Don't indent when breaking function declarations/definitions after the return type. - Indent variable declarations and typedefs when breaking after the type. This fixes llvm.org/PR17999. llvm-svn: 212591
2014-07-09 15:50:33 +08:00
// This function heuristically determines whether 'Current' starts the name of a
// function declaration.
clang-format: Improve heuristics to detect function declarations/definitions. Specifically understand ellipses in parameter lists and treat trailing reference qualifiers and the "{" as signals. llvm-svn: 266599
2016-04-18 19:31:21 +08:00
static bool isFunctionDeclarationName(const FormatToken &Current,
const AnnotatedLine &Line) {
clang-format clang-format. llvm-svn: 313744
2017-09-20 17:51:03 +08:00
auto skipOperatorName = [](const FormatToken *Next) -> const FormatToken * {
clang-format: Fix return type breaking with overloaded operator functions Differential Revision: http://reviews.llvm.org/D11177 llvm-svn: 242316
2015-07-16 03:11:58 +08:00
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[]'.
clang-format clang-format. llvm-svn: 313744
2017-09-20 17:51:03 +08:00
if (Next->Next && Next->Next->is(tok::l_square) && Next->Next->Next &&
Next->Next->Next->is(tok::r_square))
clang-format: Fix return type breaking with overloaded operator functions Differential Revision: http://reviews.llvm.org/D11177 llvm-svn: 242316
2015-07-16 03:11:58 +08:00
Next = Next->Next->Next;
continue;
}
clang-format: Revamp function declaration/definition indentation. Key changes: - Correctly (well ...) distinguish function declarations and variable declarations with ()-initialization. - Don't indent when breaking function declarations/definitions after the return type. - Indent variable declarations and typedefs when breaking after the type. This fixes llvm.org/PR17999. llvm-svn: 212591
2014-07-09 15:50:33 +08:00
break;
clang-format: Fix return type breaking with overloaded operator functions Differential Revision: http://reviews.llvm.org/D11177 llvm-svn: 242316
2015-07-16 03:11:58 +08:00
}
return nullptr;
};
clang-format: Improve heuristics to detect function declarations/definitions. Specifically understand ellipses in parameter lists and treat trailing reference qualifiers and the "{" as signals. llvm-svn: 266599
2016-04-18 19:31:21 +08:00
// Find parentheses of parameter list.
clang-format: Fix return type breaking with overloaded operator functions Differential Revision: http://reviews.llvm.org/D11177 llvm-svn: 242316
2015-07-16 03:11:58 +08:00
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)
clang-format: Revamp function declaration/definition indentation. Key changes: - Correctly (well ...) distinguish function declarations and variable declarations with ()-initialization. - Don't indent when breaking function declarations/definitions after the return type. - Indent variable declarations and typedefs when breaking after the type. This fixes llvm.org/PR17999. llvm-svn: 212591
2014-07-09 15:50:33 +08:00
return false;
clang-format: Fix return type breaking with overloaded operator functions Differential Revision: http://reviews.llvm.org/D11177 llvm-svn: 242316
2015-07-16 03:11:58 +08:00
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;
}
clang-format: Revamp function declaration/definition indentation. Key changes: - Correctly (well ...) distinguish function declarations and variable declarations with ()-initialization. - Don't indent when breaking function declarations/definitions after the return type. - Indent variable declarations and typedefs when breaking after the type. This fixes llvm.org/PR17999. llvm-svn: 212591
2014-07-09 15:50:33 +08:00
}
}
clang-format: Fix return type breaking with overloaded operator functions Differential Revision: http://reviews.llvm.org/D11177 llvm-svn: 242316
2015-07-16 03:11:58 +08:00
clang-format: Fix bad variable declaration detection. Before: LooooooooooooooooongType variable(nullptr, [](A *a) {}); After: LooooooooooooooooongType variable(nullptr, [](A *a) {}); llvm-svn: 294358
2017-02-08 05:38:16 +08:00
// Check whether parameter list can belong to a function declaration.
clang-format: Improve heuristics to detect function declarations/definitions. Specifically understand ellipses in parameter lists and treat trailing reference qualifiers and the "{" as signals. llvm-svn: 266599
2016-04-18 19:31:21 +08:00
if (!Next || !Next->is(tok::l_paren) || !Next->MatchingParen)
clang-format: Revamp function declaration/definition indentation. Key changes: - Correctly (well ...) distinguish function declarations and variable declarations with ()-initialization. - Don't indent when breaking function declarations/definitions after the return type. - Indent variable declarations and typedefs when breaking after the type. This fixes llvm.org/PR17999. llvm-svn: 212591
2014-07-09 15:50:33 +08:00
return false;
clang-format: Improve heuristics to detect function declarations/definitions. Specifically understand ellipses in parameter lists and treat trailing reference qualifiers and the "{" as signals. llvm-svn: 266599
2016-04-18 19:31:21 +08:00
// If the lines ends with "{", this is likely an function definition.
if (Line.Last->is(tok::l_brace))
return true;
clang-format: Revamp function declaration/definition indentation. Key changes: - Correctly (well ...) distinguish function declarations and variable declarations with ()-initialization. - Don't indent when breaking function declarations/definitions after the return type. - Indent variable declarations and typedefs when breaking after the type. This fixes llvm.org/PR17999. llvm-svn: 212591
2014-07-09 15:50:33 +08:00
if (Next->Next == Next->MatchingParen)
clang-format: Improve heuristics to detect function declarations/definitions. Specifically understand ellipses in parameter lists and treat trailing reference qualifiers and the "{" as signals. llvm-svn: 266599
2016-04-18 19:31:21 +08:00
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))
clang-format: Revamp function declaration/definition indentation. Key changes: - Correctly (well ...) distinguish function declarations and variable declarations with ()-initialization. - Don't indent when breaking function declarations/definitions after the return type. - Indent variable declarations and typedefs when breaking after the type. This fixes llvm.org/PR17999. llvm-svn: 212591
2014-07-09 15:50:33 +08:00
return true;
clang-format: Fix crasher on incomplete condition compilation. Previously crashing input: void f( #if A ); #else #endif llvm-svn: 226451
2015-01-19 18:52:16 +08:00
for (const FormatToken *Tok = Next->Next; Tok && Tok != Next->MatchingParen;
clang-format: Revamp function declaration/definition indentation. Key changes: - Correctly (well ...) distinguish function declarations and variable declarations with ()-initialization. - Don't indent when breaking function declarations/definitions after the return type. - Indent variable declarations and typedefs when breaking after the type. This fixes llvm.org/PR17999. llvm-svn: 212591
2014-07-09 15:50:33 +08:00
Tok = Tok->Next) {
clang-format: Fix bad variable declaration detection. Before: LooooooooooooooooongType variable(nullptr, [](A *a) {}); After: LooooooooooooooooongType variable(nullptr, [](A *a) {}); llvm-svn: 294358
2017-02-08 05:38:16 +08:00
if (Tok->is(tok::l_paren) && Tok->MatchingParen) {
Tok = Tok->MatchingParen;
continue;
}
clang-format: Revamp function declaration/definition indentation. Key changes: - Correctly (well ...) distinguish function declarations and variable declarations with ()-initialization. - Don't indent when breaking function declarations/definitions after the return type. - Indent variable declarations and typedefs when breaking after the type. This fixes llvm.org/PR17999. llvm-svn: 212591
2014-07-09 15:50:33 +08:00
if (Tok->is(tok::kw_const) || Tok->isSimpleTypeSpecifier() ||
clang-format: Improve heuristics to detect function declarations/definitions. Specifically understand ellipses in parameter lists and treat trailing reference qualifiers and the "{" as signals. llvm-svn: 266599
2016-04-18 19:31:21 +08:00
Tok->isOneOf(TT_PointerOrReference, TT_StartOfName, tok::ellipsis))
clang-format: Revamp function declaration/definition indentation. Key changes: - Correctly (well ...) distinguish function declarations and variable declarations with ()-initialization. - Don't indent when breaking function declarations/definitions after the return type. - Indent variable declarations and typedefs when breaking after the type. This fixes llvm.org/PR17999. llvm-svn: 212591
2014-07-09 15:50:33 +08:00
return true;
clang-format: Properly detect variable declarations with ObjC. Before: LoooooooooooooooooooooooooooooooooooooooongType LoooooooooooooooooooooooooooooooooooooongVariable([A a]); After: LoooooooooooooooooooooooooooooooooooooooongType LoooooooooooooooooooooooooooooooooooooongVariable([A a]); llvm-svn: 235599
2015-04-23 21:58:40 +08:00
if (Tok->isOneOf(tok::l_brace, tok::string_literal, TT_ObjCMethodExpr) ||
Tok->Tok.isLiteral())
clang-format: Revamp function declaration/definition indentation. Key changes: - Correctly (well ...) distinguish function declarations and variable declarations with ()-initialization. - Don't indent when breaking function declarations/definitions after the return type. - Indent variable declarations and typedefs when breaking after the type. This fixes llvm.org/PR17999. llvm-svn: 212591
2014-07-09 15:50:33 +08:00
return false;
}
return false;
}
Support AlwaysBreakAfterReturnType This changes the behavior of AlwaysBreakAfterDeclarationReturnType so that it supports breaking after declarations, definitions, or both. Differential Revision: http://reviews.llvm.org/D10370 Reviewed By: Daniel Jasper llvm-svn: 256046
2015-12-19 06:20:15 +08:00
bool TokenAnnotator::mustBreakForReturnType(const AnnotatedLine &Line) const {
assert(Line.MightBeFunctionDecl);
if ((Style.AlwaysBreakAfterReturnType == FormatStyle::RTBS_TopLevel ||
Style.AlwaysBreakAfterReturnType ==
FormatStyle::RTBS_TopLevelDefinitions) &&
Line.Level > 0)
return false;
switch (Style.AlwaysBreakAfterReturnType) {
case FormatStyle::RTBS_None:
return false;
case FormatStyle::RTBS_All:
case FormatStyle::RTBS_TopLevel:
return true;
case FormatStyle::RTBS_AllDefinitions:
case FormatStyle::RTBS_TopLevelDefinitions:
return Line.mightBeFunctionDefinition();
}
return false;
}
Optionally derive formatting information from the input file. With this patch, clang-format can analyze the input file for two properties: 1. Is "int *a" or "int* a" more common. 2. Are non-C++03 constructs used, e.g. A<A<A>>. With Google-style, clang-format will now use the more common style for (1) and format C++03 compatible, unless it finds C++11 constructs in the input. llvm-svn: 174504
2013-02-06 22:22:40 +08:00
void TokenAnnotator::calculateFormattingInformation(AnnotatedLine &Line) {
clang-format: Correctly calculate line lenghts for nest blocks. If simple (one-statement) blocks can be inlined, the length needs to be calculated correctly. Before (in JavaScript but this also affects lambdas, etc.): var x = { valueOf: function() { return 1; } }; After: var x = {valueOf: function() { return 1; }}; llvm-svn: 209410
2014-05-22 16:36:53 +08:00
for (SmallVectorImpl<AnnotatedLine *>::iterator I = Line.Children.begin(),
E = Line.Children.end();
I != E; ++I) {
calculateFormattingInformation(**I);
}
Calculate and store ColumnWidth instead of CodePointCount in FormatTokens. Summary: This fixes various issues with mixed tabs and spaces handling, e.g. when realigning block comments. Reviewers: klimek, djasper Reviewed By: djasper CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D1608 llvm-svn: 190395
2013-09-10 17:38:25 +08:00
Line.First->TotalLength =
[clang-format] Format raw string literals Summary: This patch adds raw string literal formatting. Reviewers: djasper, klimek Reviewed By: klimek Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D35943 llvm-svn: 316903
2017-10-30 22:01:50 +08:00
Line.First->IsMultiline ? Style.ColumnLimit
: Line.FirstStartColumn + Line.First->ColumnWidth;
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
FormatToken *Current = Line.First->Next;
clang-format: Improve formatting of constructor initializers. Before: Constructor() : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {} After: Constructor() : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa( aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {} llvm-svn: 194210
2013-11-08 01:52:51 +08:00
bool InFunctionDecl = Line.MightBeFunctionDecl;
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
while (Current) {
clang-format: Improve heuristics to detect function declarations/definitions. Specifically understand ellipses in parameter lists and treat trailing reference qualifiers and the "{" as signals. llvm-svn: 266599
2016-04-18 19:31:21 +08:00
if (isFunctionDeclarationName(*Current, Line))
clang-format: Revamp function declaration/definition indentation. Key changes: - Correctly (well ...) distinguish function declarations and variable declarations with ()-initialization. - Don't indent when breaking function declarations/definitions after the return type. - Indent variable declarations and typedefs when breaking after the type. This fixes llvm.org/PR17999. llvm-svn: 212591
2014-07-09 15:50:33 +08:00
Current->Type = TT_FunctionDeclarationName;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Current->is(TT_LineComment)) {
clang-format: Add spaces between lambdas and comments. Before: void f() { bar([]() {}// Does not respect SpacesBeforeTrailingComments ); } After: void f() { bar([]() {} // Does not respect SpacesBeforeTrailingComments ); } This fixes llvm.org/PR19017. llvm-svn: 203466
2014-03-10 23:06:25 +08:00
if (Current->Previous->BlockKind == BK_BracedInit &&
Current->Previous->opensScope())
clang-format: Add special case for leading comments in braced lists. A comment following the "{" of a braced list seems to almost always refer to the first element of the list and thus should be aligned to it. Before (with Cpp11 braced list style): SomeFunction({ // Comment 1 "first entry", // Comment 2 "second entry"}); After: SomeFunction({// Comment 1 "first entry", // Comment 2 "second entry"}); llvm-svn: 197725
2013-12-20 05:41:37 +08:00
Current->SpacesRequiredBefore = Style.Cpp11BracedListStyle ? 0 : 1;
else
Current->SpacesRequiredBefore = Style.SpacesBeforeTrailingComments;
clang-format: Preserve meaning of trailing comments on parameters. Formatting: SomeFunction(a, b, // comment c); Before: SomeFunction(a, b, // comment c); After: SomeFunction(a, b, // comment c); llvm-svn: 204456
2014-03-21 19:58:45 +08:00
// If we find a trailing comment, iterate backwards to determine whether
// it seems to relate to a specific parameter. If so, break before that
// parameter to avoid changing the comment's meaning. E.g. don't move 'b'
// to the previous line in:
// SomeFunction(a,
// b, // comment
// c);
clang-format: Fix for r204456. llvm-svn: 204457
2014-03-21 20:15:40 +08:00
if (!Current->HasUnescapedNewline) {
clang-format: Preserve meaning of trailing comments on parameters. Formatting: SomeFunction(a, b, // comment c); Before: SomeFunction(a, b, // comment c); After: SomeFunction(a, b, // comment c); llvm-svn: 204456
2014-03-21 19:58:45 +08:00
for (FormatToken *Parameter = Current->Previous; Parameter;
Parameter = Parameter->Previous) {
if (Parameter->isOneOf(tok::comment, tok::r_brace))
break;
if (Parameter->Previous && Parameter->Previous->is(tok::comma)) {
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (!Parameter->Previous->is(TT_CtorInitializerComma) &&
clang-format: Preserve meaning of trailing comments on parameters. Formatting: SomeFunction(a, b, // comment c); Before: SomeFunction(a, b, // comment c); After: SomeFunction(a, b, // comment c); llvm-svn: 204456
2014-03-21 19:58:45 +08:00
Parameter->HasUnescapedNewline)
Parameter->MustBreakBefore = true;
break;
}
}
}
clang-format: Fix various problems in formatting ObjC blocks. Among other things, this fixes llvm.org/PR15269. llvm-svn: 197900
2013-12-23 15:29:06 +08:00
} else if (Current->SpacesRequiredBefore == 0 &&
clang-format: [JS] Keep space between 'return' and '['. llvm-svn: 208090
2014-05-06 22:12:21 +08:00
spaceRequiredBefore(Line, *Current)) {
Don't break string literals inside preprocessor directives. Summary: This way we avoid breaking code which uses unknown preprocessor directives with long string literals. The specific use case in http://llvm.org/PR17035 isn't very common, but it seems to be a good idea to avoid this kind of problem anyway. Reviewers: djasper Reviewed By: djasper CC: cfe-commits, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D1813 llvm-svn: 192507
2013-10-12 05:43:05 +08:00
Current->SpacesRequiredBefore = 1;
clang-format: Add special case for leading comments in braced lists. A comment following the "{" of a braced list seems to almost always refer to the first element of the list and thus should be aligned to it. Before (with Cpp11 braced list style): SomeFunction({ // Comment 1 "first entry", // Comment 2 "second entry"}); After: SomeFunction({// Comment 1 "first entry", // Comment 2 "second entry"}); llvm-svn: 197725
2013-12-20 05:41:37 +08:00
}
Optionally derive formatting information from the input file. With this patch, clang-format can analyze the input file for two properties: 1. Is "int *a" or "int* a" more common. 2. Are non-C++03 constructs used, e.g. A<A<A>>. With Google-style, clang-format will now use the more common style for (1) and format C++03 compatible, unless it finds C++11 constructs in the input. llvm-svn: 174504
2013-02-06 22:22:40 +08:00
clang-format: Don't accidentally move tokens into preprocessor directive. This fixes llvm.org/PR17265. Before: Foo::Foo() #ifdef BAR : baz(0) #endif { } After: Foo::Foo() #ifdef BAR : baz(0) #endif { } llvm-svn: 190861
2013-09-17 17:52:48 +08:00
Current->MustBreakBefore =
Current->MustBreakBefore || mustBreakBefore(Line, *Current);
Support AlwaysBreakAfterReturnType This changes the behavior of AlwaysBreakAfterDeclarationReturnType so that it supports breaking after declarations, definitions, or both. Differential Revision: http://reviews.llvm.org/D10370 Reviewed By: Daniel Jasper llvm-svn: 256046
2015-12-19 06:20:15 +08:00
if (!Current->MustBreakBefore && InFunctionDecl &&
Current->is(TT_FunctionDeclarationName))
Current->MustBreakBefore = mustBreakForReturnType(Line);
clang-format: Add option to always break after a function's return type. This is required for GNU coding style, among others. Also update the configuration documentation. Modified from an original patch by Jarkko Hietaniemi, thank you! llvm-svn: 214858
2014-08-05 20:16:31 +08:00
Optionally derive formatting information from the input file. With this patch, clang-format can analyze the input file for two properties: 1. Is "int *a" or "int* a" more common. 2. Are non-C++03 constructs used, e.g. A<A<A>>. With Google-style, clang-format will now use the more common style for (1) and format C++03 compatible, unless it finds C++11 constructs in the input. llvm-svn: 174504
2013-02-06 22:22:40 +08:00
Current->CanBreakBefore =
Current->MustBreakBefore || canBreakBefore(Line, *Current);
clang-format: Correctly calculate line lenghts for nest blocks. If simple (one-statement) blocks can be inlined, the length needs to be calculated correctly. Before (in JavaScript but this also affects lambdas, etc.): var x = { valueOf: function() { return 1; } }; After: var x = {valueOf: function() { return 1; }}; llvm-svn: 209410
2014-05-22 16:36:53 +08:00
unsigned ChildSize = 0;
if (Current->Previous->Children.size() == 1) {
FormatToken &LastOfChild = *Current->Previous->Children[0]->Last;
ChildSize = LastOfChild.isTrailingComment() ? Style.ColumnLimit
: LastOfChild.TotalLength + 1;
}
clang-format: [Java] Support formatting qualified annotations. llvm-svn: 225559
2015-01-10 07:25:06 +08:00
const FormatToken *Prev = Current->Previous;
clang-format: Fix bad merging of lines in nested blocks. Before: SomeFunction([]() { #define A a return 43; }); After: SomeFunction([]() { #define A a return 43; }); llvm-svn: 220684
2014-10-28 00:31:46 +08:00
if (Current->MustBreakBefore || Prev->Children.size() > 1 ||
(Prev->Children.size() == 1 &&
Prev->Children[0]->First->MustBreakBefore) ||
Calculate and store ColumnWidth instead of CodePointCount in FormatTokens. Summary: This fixes various issues with mixed tabs and spaces handling, e.g. when realigning block comments. Reviewers: klimek, djasper Reviewed By: djasper CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D1608 llvm-svn: 190395
2013-09-10 17:38:25 +08:00
Current->IsMultiline)
clang-format: Fix bad merging of lines in nested blocks. Before: SomeFunction([]() { #define A a return 43; }); After: SomeFunction([]() { #define A a return 43; }); llvm-svn: 220684
2014-10-28 00:31:46 +08:00
Current->TotalLength = Prev->TotalLength + Style.ColumnLimit;
Optionally derive formatting information from the input file. With this patch, clang-format can analyze the input file for two properties: 1. Is "int *a" or "int* a" more common. 2. Are non-C++03 constructs used, e.g. A<A<A>>. With Google-style, clang-format will now use the more common style for (1) and format C++03 compatible, unless it finds C++11 constructs in the input. llvm-svn: 174504
2013-02-06 22:22:40 +08:00
else
clang-format: Fix bad merging of lines in nested blocks. Before: SomeFunction([]() { #define A a return 43; }); After: SomeFunction([]() { #define A a return 43; }); llvm-svn: 220684
2014-10-28 00:31:46 +08:00
Current->TotalLength = Prev->TotalLength + Current->ColumnWidth +
ChildSize + Current->SpacesRequiredBefore;
clang-format: Improve formatting of constructor initializers. Before: Constructor() : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {} After: Constructor() : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa( aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {} llvm-svn: 194210
2013-11-08 01:52:51 +08:00
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Current->is(TT_CtorInitializerColon))
clang-format: Improve formatting of constructor initializers. Before: Constructor() : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {} After: Constructor() : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa( aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {} llvm-svn: 194210
2013-11-08 01:52:51 +08:00
InFunctionDecl = false;
Optionally derive formatting information from the input file. With this patch, clang-format can analyze the input file for two properties: 1. Is "int *a" or "int* a" more common. 2. Are non-C++03 constructs used, e.g. A<A<A>>. With Google-style, clang-format will now use the more common style for (1) and format C++03 compatible, unless it finds C++11 constructs in the input. llvm-svn: 174504
2013-02-06 22:22:40 +08:00
// FIXME: Only calculate this if CanBreakBefore is true once static
// initializers etc. are sorted out.
// FIXME: Move magic numbers to a better place.
clang-format: Improve formatting of constructor initializers. Before: Constructor() : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {} After: Constructor() : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa( aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {} llvm-svn: 194210
2013-11-08 01:52:51 +08:00
Current->SplitPenalty = 20 * Current->BindingStrength +
splitPenalty(Line, *Current, InFunctionDecl);
Optionally derive formatting information from the input file. With this patch, clang-format can analyze the input file for two properties: 1. Is "int *a" or "int* a" more common. 2. Are non-C++03 constructs used, e.g. A<A<A>>. With Google-style, clang-format will now use the more common style for (1) and format C++03 compatible, unless it finds C++11 constructs in the input. llvm-svn: 174504
2013-02-06 22:22:40 +08:00
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
Current = Current->Next;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
}
Revamp indentation behavior for complex binary expressions. The idea is to indent according to operator precedence and pretty much identical to how stuff would be indented with parenthesis. Before: bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa > ccccccccccccccccccccccccccccccccccccccccc; After: bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa > ccccccccccccccccccccccccccccccccccccccccc; llvm-svn: 179049
2013-04-09 04:33:42 +08:00
Makes whitespace management more consistent. Instead of selectively storing some changes and directly generating replacements for others, we now notify the WhitespaceManager of the whitespace before every token (and optionally with more changes inside tokens). Then, we run over all whitespace in the very end in original source order, where we have all information available to correctly align comments and escaped newlines. The future direction is to pull more of the comment alignment implementation that is now in the BreakableToken into the WhitespaceManager. This fixes a bug when aligning comments or escaped newlines in unwrapped lines that are handled out of order: #define A \ f({ \ g(); \ }); ... now gets correctly layouted. llvm-svn: 182467
2013-05-22 20:51:29 +08:00
calculateUnbreakableTailLengths(Line);
[clang-format] Refactor WhitespaceManager and friends The main motivation behind this is to cleanup the WhitespaceManager and make it more extensible for future alignment etc. features. Specifically, WhitespaceManager has started to copy more and more code that is already present in FormatToken. Instead, I think it makes more sense to actually store a reference to each FormatToken for each change. This has as a consequence led to a change in the calculation of indent levels. Now, we actually compute them for each Token ahead of time, which should be more efficient as it removes an unsigned value for the ParenState, which is used during the combinatorial exploration of the solution space. No functional changes intended. Review: https://reviews.llvm.org/D29300 llvm-svn: 293616
2017-01-31 19:25:01 +08:00
unsigned IndentLevel = Line.Level;
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
for (Current = Line.First; Current != nullptr; Current = Current->Next) {
clang-format: Add column layout formatting for braced lists With this patch, braced lists (with more than 3 elements are formatted in a column layout if possible). E.g.: static const uint16_t CallerSavedRegs64Bit[] = { X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI, X86::R8, X86::R9, X86::R10, X86::R11, 0 }; Required other changes: - FormatTokens can now have a special role that contains extra data and can do special formattings. A comma separated list is currently the only implementation. - Move penalty calculation entirely into ContinuationIndenter (there was a last piece still in UnwrappedLineFormatter). Review: http://llvm-reviews.chandlerc.com/D1457 llvm-svn: 189018
2013-08-22 23:00:41 +08:00
if (Current->Role)
Current->Role->precomputeFormattingInfos(Current);
[clang-format] Refactor WhitespaceManager and friends The main motivation behind this is to cleanup the WhitespaceManager and make it more extensible for future alignment etc. features. Specifically, WhitespaceManager has started to copy more and more code that is already present in FormatToken. Instead, I think it makes more sense to actually store a reference to each FormatToken for each change. This has as a consequence led to a change in the calculation of indent levels. Now, we actually compute them for each Token ahead of time, which should be more efficient as it removes an unsigned value for the ParenState, which is used during the combinatorial exploration of the solution space. No functional changes intended. Review: https://reviews.llvm.org/D29300 llvm-svn: 293616
2017-01-31 19:25:01 +08:00
if (Current->MatchingParen &&
Current->MatchingParen->opensBlockOrBlockTypeList(Style)) {
assert(IndentLevel > 0);
--IndentLevel;
}
Current->IndentLevel = IndentLevel;
if (Current->opensBlockOrBlockTypeList(Style))
++IndentLevel;
clang-format: Add column layout formatting for braced lists With this patch, braced lists (with more than 3 elements are formatted in a column layout if possible). E.g.: static const uint16_t CallerSavedRegs64Bit[] = { X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI, X86::R8, X86::R9, X86::R10, X86::R11, 0 }; Required other changes: - FormatTokens can now have a special role that contains extra data and can do special formattings. A comma separated list is currently the only implementation. - Move penalty calculation entirely into ContinuationIndenter (there was a last piece still in UnwrappedLineFormatter). Review: http://llvm-reviews.chandlerc.com/D1457 llvm-svn: 189018
2013-08-22 23:00:41 +08:00
}
[clang] Update uses of DEBUG macro to LLVM_DEBUG. The DEBUG() macro is very generic so it might clash with other projects. The renaming was done as follows: - git grep -l 'DEBUG' | xargs sed -i 's/\bDEBUG\s\?(/LLVM_DEBUG(/g' - git diff -U0 master | ../clang/tools/clang-format/clang-format-diff.py -i -p1 -style LLVM Explicitly avoided changing the strings in the clang-format tests. Differential Revision: https://reviews.llvm.org/D44975 llvm-svn: 332350
2018-05-15 21:30:56 +08:00
LLVM_DEBUG({ printDebugInfo(Line); });
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
}
Makes whitespace management more consistent. Instead of selectively storing some changes and directly generating replacements for others, we now notify the WhitespaceManager of the whitespace before every token (and optionally with more changes inside tokens). Then, we run over all whitespace in the very end in original source order, where we have all information available to correctly align comments and escaped newlines. The future direction is to pull more of the comment alignment implementation that is now in the BreakableToken into the WhitespaceManager. This fixes a bug when aligning comments or escaped newlines in unwrapped lines that are handled out of order: #define A \ f({ \ g(); \ }); ... now gets correctly layouted. llvm-svn: 182467
2013-05-22 20:51:29 +08:00
void TokenAnnotator::calculateUnbreakableTailLengths(AnnotatedLine &Line) {
unsigned UnbreakableTailLength = 0;
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
FormatToken *Current = Line.Last;
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
while (Current) {
Makes whitespace management more consistent. Instead of selectively storing some changes and directly generating replacements for others, we now notify the WhitespaceManager of the whitespace before every token (and optionally with more changes inside tokens). Then, we run over all whitespace in the very end in original source order, where we have all information available to correctly align comments and escaped newlines. The future direction is to pull more of the comment alignment implementation that is now in the BreakableToken into the WhitespaceManager. This fixes a bug when aligning comments or escaped newlines in unwrapped lines that are handled out of order: #define A \ f({ \ g(); \ }); ... now gets correctly layouted. llvm-svn: 182467
2013-05-22 20:51:29 +08:00
Current->UnbreakableTailLength = UnbreakableTailLength;
if (Current->CanBreakBefore ||
Current->isOneOf(tok::comment, tok::string_literal)) {
UnbreakableTailLength = 0;
} else {
UnbreakableTailLength +=
Calculate and store ColumnWidth instead of CodePointCount in FormatTokens. Summary: This fixes various issues with mixed tabs and spaces handling, e.g. when realigning block comments. Reviewers: klimek, djasper Reviewed By: djasper CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D1608 llvm-svn: 190395
2013-09-10 17:38:25 +08:00
Current->ColumnWidth + Current->SpacesRequiredBefore;
Makes whitespace management more consistent. Instead of selectively storing some changes and directly generating replacements for others, we now notify the WhitespaceManager of the whitespace before every token (and optionally with more changes inside tokens). Then, we run over all whitespace in the very end in original source order, where we have all information available to correctly align comments and escaped newlines. The future direction is to pull more of the comment alignment implementation that is now in the BreakableToken into the WhitespaceManager. This fixes a bug when aligning comments or escaped newlines in unwrapped lines that are handled out of order: #define A \ f({ \ g(); \ }); ... now gets correctly layouted. llvm-svn: 182467
2013-05-22 20:51:29 +08:00
}
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
Current = Current->Previous;
Makes whitespace management more consistent. Instead of selectively storing some changes and directly generating replacements for others, we now notify the WhitespaceManager of the whitespace before every token (and optionally with more changes inside tokens). Then, we run over all whitespace in the very end in original source order, where we have all information available to correctly align comments and escaped newlines. The future direction is to pull more of the comment alignment implementation that is now in the BreakableToken into the WhitespaceManager. This fixes a bug when aligning comments or escaped newlines in unwrapped lines that are handled out of order: #define A \ f({ \ g(); \ }); ... now gets correctly layouted. llvm-svn: 182467
2013-05-22 20:51:29 +08:00
}
}
Optionally derive formatting information from the input file. With this patch, clang-format can analyze the input file for two properties: 1. Is "int *a" or "int* a" more common. 2. Are non-C++03 constructs used, e.g. A<A<A>>. With Google-style, clang-format will now use the more common style for (1) and format C++03 compatible, unless it finds C++11 constructs in the input. llvm-svn: 174504
2013-02-06 22:22:40 +08:00
unsigned TokenAnnotator::splitPenalty(const AnnotatedLine &Line,
clang-format: Improve formatting of constructor initializers. Before: Constructor() : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {} After: Constructor() : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa( aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {} llvm-svn: 194210
2013-11-08 01:52:51 +08:00
const FormatToken &Tok,
bool InFunctionDecl) {
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
const FormatToken &Left = *Tok.Previous;
const FormatToken &Right = Tok;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
Initial support for designated initializers. llvm-svn: 182767
2013-05-28 19:30:49 +08:00
if (Left.is(tok::semi))
return 0;
clang-format: [Java] Fix line break behavior of class declarations. Change breaking preferences: 1. Break before "extends" 2. Break before "implements" 3. Break within the implements list. llvm-svn: 221981
2014-11-14 18:15:56 +08:00
if (Style.Language == FormatStyle::LK_Java) {
clang-format: [Java] Improve formatting of throws declarations. Before: public void doSoooooooooo() throws LoooooooooongException, LooooooooooongException {} After: public void doSoooooooooo() throws LoooooooooongException, LooooooooooongException {} llvm-svn: 222829
2014-11-26 20:31:19 +08:00
if (Right.isOneOf(Keywords.kw_extends, Keywords.kw_throws))
clang-format: [Java] Fix line break behavior of class declarations. Change breaking preferences: 1. Break before "extends" 2. Break before "implements" 3. Break within the implements list. llvm-svn: 221981
2014-11-14 18:15:56 +08:00
return 1;
if (Right.is(Keywords.kw_implements))
return 2;
if (Left.is(tok::comma) && Left.NestingLevel == 0)
return 3;
clang-format: [JS] Contract fewer functions to a single line. Before: var someVariable = function(x) { return x.zIsTooLongForOneLineWithTheDeclarationLine(); }; After: var someVariable = function(x) { return x.zIsTooLongForOneLineWithTheDeclarationLine(); }; llvm-svn: 222893
2014-11-27 23:37:42 +08:00
} else if (Style.Language == FormatStyle::LK_JavaScript) {
clang-format: [JS] Avoid bad line-warp around "function". Before: someLooooooooongFunction( aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, function( aaaaaaaaaaaaaaaaaaaaaaaaaaaaa) { // code }); After: someLooooooooongFunction( aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, function(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa) { // code }); llvm-svn: 236813
2015-05-08 16:38:52 +08:00
if (Right.is(Keywords.kw_function) && Left.isNot(tok::comma))
clang-format: [JS] Contract fewer functions to a single line. Before: var someVariable = function(x) { return x.zIsTooLongForOneLineWithTheDeclarationLine(); }; After: var someVariable = function(x) { return x.zIsTooLongForOneLineWithTheDeclarationLine(); }; llvm-svn: 222893
2014-11-27 23:37:42 +08:00
return 100;
clang-format: [JS] Assign proper penalties when breaking a type annotation Before: class Test { aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa: aaaaaaaaaaaaaaaaaaaaaaaa): aaaaaaaaaaaaaaaaaaaaaa {} } After: class Test { aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa: aaaaaaaaaaaaaaaaaaaaaaaa): aaaaaaaaaaaaaaaaaaaaaa {} } llvm-svn: 241908
2015-07-10 21:39:26 +08:00
if (Left.is(TT_JsTypeColon))
clang-format: [JS] Prefer wrapping before the TypeScript return type over wrapping before parameters. Before: function someFunc( args: string[]): {longReturnValue: string[]} {} After: function someFunc(args: string[]): {longReturnValue: string[]} {} llvm-svn: 257162
2016-01-08 18:51:24 +08:00
return 35;
clang-format: [JS] nested and tagged template strings. JavaScript template strings can be nested arbitrarily: foo = `text ${es.map(e => { return `<${e}>`; })} text`; This change lexes nested template strings using a stack of lexer states to correctly switch back to template string lexing on closing braces. Also, reuse the same stack for the token-stashed logic. Reviewers: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D22431 llvm-svn: 279727
2016-08-25 18:13:21 +08:00
if ((Left.is(TT_TemplateString) && Left.TokenText.endswith("${")) ||
(Right.is(TT_TemplateString) && Right.TokenText.startswith("}")))
return 100;
clang-format: [JS] prefer wrapping chains over empty literals. Summary: E.g. don't wrap like this: (foo.bar.baz).and.bam(Blah.of({ })) But rather: (foo.bar.baz) .and.bam(Blah.of({})) Reviewers: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D36139 llvm-svn: 309712
2017-08-02 01:35:57 +08:00
// Prefer breaking call chains (".foo") over empty "{}", "[]" or "()".
if (Left.opensScope() && Right.closesScope())
return 200;
clang-format: [Java] Fix line break behavior of class declarations. Change breaking preferences: 1. Break before "extends" 2. Break before "implements" 3. Break within the implements list. llvm-svn: 221981
2014-11-14 18:15:56 +08:00
}
clang-format: Keep string-literal-label + value pairs on a line. We have previously done that for <<-operators. This patch also adds this logic for "," and "+". Before: string v = "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa + "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa + "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa; string v = StrCat("aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa, "aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa, "aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa); After: string v = "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa + "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa + "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa; string v = StrCat("aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa, "aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa, "aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa); llvm-svn: 289531
2016-12-13 19:16:42 +08:00
if (Right.is(tok::identifier) && Right.Next && Right.Next->is(TT_DictLiteral))
Initial support for designated initializers. llvm-svn: 182767
2013-05-28 19:30:49 +08:00
return 1;
clang-format: Better support and testing for protocol buffers. With this patch, there is dedicated testing for protocol buffers (https://developers.google.com/protocol-buffers/). Also some minor tweaks formatting tweaks. llvm-svn: 199580
2014-01-19 17:04:08 +08:00
if (Right.is(tok::l_square)) {
clang-format: Slightly row back on r256343 by increasing penalty for breaking between array subscripts. Before: if (aaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa] [aaaaaaaaaaaaa]) After: if (aaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) llvm-svn: 256640
2015-12-30 20:23:00 +08:00
if (Style.Language == FormatStyle::LK_Proto)
clang-format: Better support and testing for protocol buffers. With this patch, there is dedicated testing for protocol buffers (https://developers.google.com/protocol-buffers/). Also some minor tweaks formatting tweaks. llvm-svn: 199580
2014-01-19 17:04:08 +08:00
return 1;
clang-format: Slightly row back on r256343 by increasing penalty for breaking between array subscripts. Before: if (aaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa] [aaaaaaaaaaaaa]) After: if (aaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) llvm-svn: 256640
2015-12-30 20:23:00 +08:00
if (Left.is(tok::r_square))
clang-format: Increase the penalty for breaking between array subscripts. Before: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaa] [a].aaaaaaaaaaaaaaaaaaaaaa(); After: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaa][a] .aaaaaaaaaaaaaaaaaaaaaa(); llvm-svn: 262292
2016-03-01 12:19:55 +08:00
return 200;
clang-format: Prefer formatting local lambdas like functions. Before: auto my_lambda = [](const string &some_parameter) { return some_parameter.size(); }; After: auto my_lambda = [](const string &some_parameter) { return some_parameter.size(); }; llvm-svn: 237235
2015-05-13 16:47:16 +08:00
// Slightly prefer formatting local lambda definitions like functions.
if (Right.is(TT_LambdaLSquare) && Left.is(tok::equal))
clang-format: Fix corner case for lambda assignments. Before: std::function<std::string(const std::string &)> my_lambda = []( const string &s) { return s; }; After: std::function<std::string(const std::string &)> my_lambda = [](const string &s) { return s; }; llvm-svn: 256739
2016-01-04 15:29:40 +08:00
return 35;
clang-format: [JS] More aggressively keep array literals on one line. Before: var aaaaa: List<SomeThing> = [ new SomeThingAAAAAAAAAAAA(), new SomeThingBBBBBBBBB() ]; After: var aaaaa: List<SomeThing> = [new SomeThingAAAAAAAAAAAA(), new SomeThingBBBBBBBBB()]; llvm-svn: 238909
2015-06-03 16:57:36 +08:00
if (!Right.isOneOf(TT_ObjCMethodExpr, TT_LambdaLSquare,
clang-format: Fix C99 designated initializers corner cases Summary: This fixes the missing space before the designated initializer when `Cpp11BracedListStyle=false` : const struct A a = { .a = 1, .b = 2 }; ^ Also, wrapping between opening brace and designated array initializers used to have an excessive penalty (like breaking between an expression and the subscript operator), leading to unexpected wrapping: const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {[1] = aaaaaaaaaaaaaaaaaaaaaaaaaaa, [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbb}; instead of: const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = { [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaa, [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbb}; Finally, designated array initializers are not binpacked, just like designated member initializers. Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, krasimir, klimek Differential Revision: https://reviews.llvm.org/D33491 llvm-svn: 305696
2017-06-19 22:41:21 +08:00
TT_ArrayInitializerLSquare,
[clang-format] Don't detect C++11 attribute specifiers as ObjC Summary: Previously, clang-format would detect C++11 and C++17 attribute specifiers like the following as Objective-C method invocations: [[noreturn]]; [[clang::fallthrough]]; [[noreturn, deprecated("so sorry")]]; [[using gsl: suppress("type")]]; To fix this, I ported part of the logic from tools/clang/lib/Parse/ParseTentative.cpp into TokenAnnotator.cpp so we can explicitly parse and identify C++11 attribute specifiers. This allows the guessLanguage() and getStyle() APIs to correctly guess files containing the C++11 attribute specifiers as C++, not Objective-C. Test Plan: New tests added. Ran tests with: make -j12 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: krasimir, jolesiak, djasper Reviewed By: djasper Subscribers: aaron.ballman, cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D43902 llvm-svn: 327284
2018-03-12 23:42:38 +08:00
TT_DesignatedInitializerLSquare, TT_AttributeSquare))
clang-format: Increase penalty for wrapping array subscript expressions Before: aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0].aaaaaaa [0].aaaaaaaaaaaaaaaaaaaaaa(); After: aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0] .aaaaaaa[0] .aaaaaaaaaaaaaaaaaaaaaa(); llvm-svn: 210529
2014-06-10 21:27:57 +08:00
return 500;
clang-format: Better support and testing for protocol buffers. With this patch, there is dedicated testing for protocol buffers (https://developers.google.com/protocol-buffers/). Also some minor tweaks formatting tweaks. llvm-svn: 199580
2014-01-19 17:04:08 +08:00
}
clang-format: [Java] Fix line break behavior of class declarations. Change breaking preferences: 1. Break before "extends" 2. Break before "implements" 3. Break within the implements list. llvm-svn: 221981
2014-11-14 18:15:56 +08:00
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Right.isOneOf(TT_StartOfName, TT_FunctionDeclarationName) ||
Right.is(tok::kw_operator)) {
clang-format: NFC. Add a function to test whether an annotated line starts with a given sequence of tokens. Only the one-token version is used yet, but other usages are coming up momentarily. llvm-svn: 239892
2015-06-17 17:43:56 +08:00
if (Line.startsWith(tok::kw_for) && Right.PartOfMultiVariableDeclStmt)
Allow breaking between a type and name in variable declarations. This fixes llvm.org/PR14967 and is generall necessary to avoid situations where the column limit is exceeded. The challenge is restricting such lines splits, otherwise clang-format suddenly starts breaking at bad places. Before: ReallyLongReturnType<TemplateParam1, TemplateParam2> ReallyReallyLongFunctionName( const std::string &SomeParameter, const SomeType<string, SomeOtherTemplateParameter> &ReallyReallyLongParameterName, const SomeType<string, SomeOtherTemplateParameter> &AnotherLongParameterName) {} After: ReallyLongReturnType<TemplateParam1, TemplateParam2> ReallyReallyLongFunctionName( const std::string &SomeParameter, const SomeType<string, SomeOtherTemplateParameter> & ReallyReallyLongParameterName, const SomeType<string, SomeOtherTemplateParameter> & AnotherLongParameterName) {} llvm-svn: 175999
2013-02-25 02:54:32 +08:00
return 3;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Left.is(TT_StartOfName))
clang-format: Slightly change format decisions around macro annotations. Before: bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) = aaaaaaaaaaaaaaaaaaaaaaaaa; After: bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) = aaaaaaaaaaaaaaaaaaaaaaaaa; llvm-svn: 237430
2015-05-15 17:58:11 +08:00
return 110;
clang-format: Be more conservative about braced list column layout. Specifically disable it for nested braced lists as it commonly can look really weird. Eventually, we'll want to become smarter and format some of the nested lists better. Before: SomeStruct my_struct_array = { { aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaa, aaa }, { aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa }, { aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa }, }; After: SomeStruct my_struct_array = { { aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaa, aaaaaaa, aaa }, { aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa }, { aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa }, }; llvm-svn: 196783
2013-12-09 22:40:19 +08:00
if (InFunctionDecl && Right.NestingLevel == 0)
Allow breaking between a type and name in variable declarations. This fixes llvm.org/PR14967 and is generall necessary to avoid situations where the column limit is exceeded. The challenge is restricting such lines splits, otherwise clang-format suddenly starts breaking at bad places. Before: ReallyLongReturnType<TemplateParam1, TemplateParam2> ReallyReallyLongFunctionName( const std::string &SomeParameter, const SomeType<string, SomeOtherTemplateParameter> &ReallyReallyLongParameterName, const SomeType<string, SomeOtherTemplateParameter> &AnotherLongParameterName) {} After: ReallyLongReturnType<TemplateParam1, TemplateParam2> ReallyReallyLongFunctionName( const std::string &SomeParameter, const SomeType<string, SomeOtherTemplateParameter> & ReallyReallyLongParameterName, const SomeType<string, SomeOtherTemplateParameter> & AnotherLongParameterName) {} llvm-svn: 175999
2013-02-25 02:54:32 +08:00
return Style.PenaltyReturnTypeOnItsOwnLine;
clang-format: Fix return type line break decision. This accidentally introduced by r186077, as function names were not correctly recognized in templated declarations. Before: template <class TemplateIt> SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end, TemplateIt* stop) {} After: template <class TemplateIt> SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end, TemplateIt* stop) {} llvm-svn: 188665
2013-08-19 18:16:18 +08:00
return 200;
Allow breaking between a type and name in variable declarations. This fixes llvm.org/PR14967 and is generall necessary to avoid situations where the column limit is exceeded. The challenge is restricting such lines splits, otherwise clang-format suddenly starts breaking at bad places. Before: ReallyLongReturnType<TemplateParam1, TemplateParam2> ReallyReallyLongFunctionName( const std::string &SomeParameter, const SomeType<string, SomeOtherTemplateParameter> &ReallyReallyLongParameterName, const SomeType<string, SomeOtherTemplateParameter> &AnotherLongParameterName) {} After: ReallyLongReturnType<TemplateParam1, TemplateParam2> ReallyReallyLongFunctionName( const std::string &SomeParameter, const SomeType<string, SomeOtherTemplateParameter> & ReallyReallyLongParameterName, const SomeType<string, SomeOtherTemplateParameter> & AnotherLongParameterName) {} llvm-svn: 175999
2013-02-25 02:54:32 +08:00
}
clang-format: When putting */& next to types, also wrap before them. Before: LoooooooooooongType * loooooooooooongVariable; After: LoooooooooooongType *loooooooooooongVariable; llvm-svn: 232044
2015-03-12 23:04:53 +08:00
if (Right.is(TT_PointerOrReference))
clang-format: Fix another bug in wrapping around "*". Before: void aaaaa( aaaaaaaaaaaa* aaaaaaaaaaaaaa) {} // even violation the column limit After: void aaaaa(aaaaaaaaaaaa* aaaaaaaaaaaaaa) {} llvm-svn: 232717
2015-03-19 17:40:16 +08:00
return 190;
clang-format: More eagerly wrap trailing return types. Before: template <typename T> auto aaaaaaaaaaaaaaaaaaaaaa(T t) -> decltype(eaaaaaaaaaaaaaaa<T>(t.a) .aaaaaaaa()); After: template <typename T> auto aaaaaaaaaaaaaaaaaaaaaa(T t) -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa()); Also add a test case for a difficult template parsing case I stumbled accross. Needs fixing. llvm-svn: 239149
2015-06-05 21:18:09 +08:00
if (Right.is(TT_LambdaArrow))
clang-format: Prefer wrapping a lambda's body over the lambda's return type. Before: aaaaaaaaaaaaaaaaaaaaaa( [](aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaaaaaaa { return aaaaaaaaaaaaaaaaa; }); After: aaaaaaaaaaaaaaaaaaaaaa( [](aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaaaaaaa { return aaaaaaaaaaaaaaaaa; }); llvm-svn: 230942
2015-03-02 18:35:13 +08:00
return 110;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
if (Left.is(tok::equal) && Right.is(tok::l_brace))
clang-format: Make it very slighly more expensive to wrap between "= {". This prevents unwanted fallout from r296664. Specifically in proto formatting, this changed: optional Aaaaaaaa aaaaaaaa = 12 [ (aaa) = aaaa, (bbbbbbbbbbbbbbbbbbbbbbbbbb) = { aaaaaaaaaaaaaaaaa: true, aaaaaaaaaaaaaaaa: true } ]; Into: optional Aaaaaaaa aaaaaaaa = 12 [ (aaa) = aaaa, (bbbbbbbbbbbbbbbbbbbbbbbbbb) = {aaaaaaaaaaaaaaaaa: true, aaaaaaaaaaaaaaaa: true} ]; Which is considered less readable. Generally, it seems preferable to format such dict literals as blocks rather than contract them to one line. llvm-svn: 297696
2017-03-14 08:40:32 +08:00
return 160;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Left.is(TT_CastRParen))
Don't break after a "(" following a binary operator. Additionally, allow breaking after c-style casts, but with a high penalty. Before: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = ( aaaaaaaaaaaaaaaaa *)bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; After: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *) bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; This fixes llvm.org/PR16049. llvm-svn: 185685
2013-07-05 15:58:34 +08:00
return 100;
clang-format: Treat "." in protos like namespace separators. Before: optional really.really.long.and.qualified.type.aaaaaaa .aaaaaaaa another_fiiiiiiiiiiiiiiiiiiiiield = 2; After: optional really.really.long.and.qualified.type.aaaaaaa.aaaaaaaa another_fiiiiiiiiiiiiiiiiiiiiield = 2; llvm-svn: 199796
2014-01-22 16:04:52 +08:00
if (Left.is(tok::coloncolon) ||
(Right.is(tok::period) && Style.Language == FormatStyle::LK_Proto))
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return 500;
Allow breaking after 'class' for classes with looong names. (Don't ask, this was a user request). llvm-svn: 178888
2013-04-06 01:22:09 +08:00
if (Left.isOneOf(tok::kw_class, tok::kw_struct))
return 5000;
clang-format: Allow splitting the line after /**/-comments. While it might change the meaning of the comment in rare circumstances, it is better than violating the column limit. llvm-svn: 270975
2016-05-27 16:59:34 +08:00
if (Left.is(tok::comment))
return 1000;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
clang-format clang-format. llvm-svn: 313744
2017-09-20 17:51:03 +08:00
if (Left.isOneOf(TT_RangeBasedForLoopColon, TT_InheritanceColon,
TT_CtorInitializerColon))
In range-based for-loops, prefer splitting after ":". Before: for (const aaaaaaaaaaaaaaaaaaaaa & aaaaaaaaa : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {} After: for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {} llvm-svn: 176087
2013-02-26 21:18:08 +08:00
return 2;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
clang-format: Format segments of builder-type calls one per line. This fixes llvm.org/PR14818. Before: return llvm::StringSwitch<Reference::Kind>(name) .StartsWith(".eh_frame_hdr", ORDER_EH_FRAMEHDR) .StartsWith(".eh_frame", ORDER_EH_FRAME) .StartsWith(".init", ORDER_INIT).StartsWith(".fini", ORDER_FINI) .StartsWith(".hash", ORDER_HASH).Default(ORDER_TEXT); After: return llvm::StringSwitch<Reference::Kind>(name) .StartsWith(".eh_frame_hdr", ORDER_EH_FRAMEHDR) .StartsWith(".eh_frame", ORDER_EH_FRAME) .StartsWith(".init", ORDER_INIT) .StartsWith(".fini", ORDER_FINI) .StartsWith(".hash", ORDER_HASH) .Default(ORDER_TEXT); llvm-svn: 189353
2013-08-27 22:24:43 +08:00
if (Right.isMemberAccess()) {
clang-format: Make wrapping after "./->" cheaper, even if the element before it is not a closing parenthesis. Otherwise, this frequently leads to "hanging" indents that users perceive as "weird". Before: return !soooooooooooooome_map.insert( aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) .second; After: return !soooooooooooooome_map .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) .second; llvm-svn: 254933
2015-12-08 03:50:48 +08:00
// Breaking before the "./->" of a chained call/member access is reasonably
// cheap, as formatting those with one call per line is generally
// desirable. In particular, it should be cheaper to break before the call
// than it is to break inside a call's parameters, which could lead to weird
// "hanging" indents. The exception is the very last "./->" to support this
// frequent pattern:
//
// aaaaaaaa.aaaaaaaa.bbbbbbb().ccccccccccccccccccccc(
// dddddddd);
//
// which might otherwise be blown up onto many lines. Here, clang-format
// won't produce "hanging" indents anyway as there is no other trailing
// call.
clang-format: Improve line wrapping behavior in call sequences. r256750 has been leading to an undesired behavior: aaaaaaaaaa .aaaaaaaaaaaaaaaaaaaaaaaa.aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa); This change increases penalty for wrapping before member accesses that aren't calls. Thus, this is again formatted as (as it has been before r256750): aaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaa.aaaaaa( aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa); llvm-svn: 256830
2016-01-05 21:03:50 +08:00
//
// Also apply higher penalty is not a call as that might lead to a wrapping
// like:
//
// aaaaaaa
// .aaaaaaaaa.bbbbbbbb(cccccccc);
return !Right.NextOperator || !Right.NextOperator->Previous->closesScope()
? 150
: 35;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
}
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Right.is(TT_TrailingAnnotation) &&
clang-format: Fix trailing const (etc.) with Allman brace style. Before: void someLongFunction(int someLongParameter) const { } After: void someLongFunction( int someLongParameter) const { } This fixes llvm.org/PR19912. llvm-svn: 210010
2014-06-02 17:52:08 +08:00
(!Right.Next || Right.Next->isNot(tok::l_paren))) {
clang-format: [ObjC] Wrap ObjC method declarations before annotations. Before: - (instancetype)initXxxxxxxxxxxxxxxxxxxxxxxxx:(id<x>)x y:(id<yyyyyyyyyyyyyyyyyyyy>) y NS_DESIGNATED_INITIALIZER; After: - (instancetype)initXxxxxxxxxxxxxxxxxxxxxxxxx:(id<x>)x y:(id<yyyyyyyyyyyyyyyyyyyy>)y NS_DESIGNATED_INITIALIZER; llvm-svn: 219564
2014-10-11 16:24:56 +08:00
// Moving trailing annotations to the next line is fine for ObjC method
// declarations.
clang-format: NFC. Add a function to test whether an annotated line starts with a given sequence of tokens. Only the one-token version is used yet, but other usages are coming up momentarily. llvm-svn: 239892
2015-06-17 17:43:56 +08:00
if (Line.startsWith(TT_ObjCMethodSpecifier))
clang-format: [ObjC] Wrap ObjC method declarations before annotations. Before: - (instancetype)initXxxxxxxxxxxxxxxxxxxxxxxxx:(id<x>)x y:(id<yyyyyyyyyyyyyyyyyyyy>) y NS_DESIGNATED_INITIALIZER; After: - (instancetype)initXxxxxxxxxxxxxxxxxxxxxxxxx:(id<x>)x y:(id<yyyyyyyyyyyyyyyyyyyy>)y NS_DESIGNATED_INITIALIZER; llvm-svn: 219564
2014-10-11 16:24:56 +08:00
return 10;
clang-format: Don't wrap "const" etc. of function declarations. Generally people seem to prefer wrapping the first function parameter over wrapping the trailing tokens "const", "override" and "final". This does not extend to function-like annotations and probably not to other non-standard annotations. Before: void someLongFunction(int SomeLongParameter) const { ... } After: void someLongFunction( int SomeLongParameter) const { ... } llvm-svn: 201504
2014-02-17 15:57:46 +08:00
// Generally, breaking before a trailing annotation is bad unless it is
// function-like. It seems to be especially preferable to keep standard
// annotations (i.e. "const", "final" and "override") on the same line.
clang-format: Keep trailing annotations together. Before: virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa, aaaaaaaaaaa aaaaa) const override; virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa() const override; After: virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa, aaaaaaaaaaa aaaaa) const override; virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa() const override; llvm-svn: 197391
2013-12-16 23:01:54 +08:00
// Use a slightly higher penalty after ")" so that annotations like
// "const override" are kept together.
clang-format: Keep more trailing annotations on the same line. More precisely keep all short annotations (<10 characters) on the same line if possible. Previously, clang-format would only prefer to do so for "const", "override" and "final". However, it seems to be generally preferable, especially because some codebases have to wrap those in macros for backwards compatibility. Before: void someLongFunction(int someLongParameter) OVERRIDE {} After: void someLongFunction( int someLongParameter) OVERRIDE {} This fixes llvm.org/PR19363. llvm-svn: 205845
2014-04-09 18:01:49 +08:00
bool is_short_annotation = Right.TokenText.size() < 10;
clang-format: Fix bug introduced by r208392. Also run clang-format over clang-format's files. llvm-svn: 208409
2014-05-09 21:11:16 +08:00
return (Left.is(tok::r_paren) ? 100 : 120) + (is_short_annotation ? 50 : 0);
clang-format: Keep trailing annotations together. Before: virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa, aaaaaaaaaaa aaaaa) const override; virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa() const override; After: virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa, aaaaaaaaaaa aaaaa) const override; virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa() const override; llvm-svn: 197391
2013-12-16 23:01:54 +08:00
}
Improve handling of trailing 'const'. Reduce the preference for breaking before a trailing 'const' according to review comments on r182362. llvm-svn: 182455
2013-05-22 16:28:26 +08:00
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
// In for-loops, prefer breaking at ',' and ';'.
clang-format: NFC. Add a function to test whether an annotated line starts with a given sequence of tokens. Only the one-token version is used yet, but other usages are coming up momentarily. llvm-svn: 239892
2015-06-17 17:43:56 +08:00
if (Line.startsWith(tok::kw_for) && Left.is(tok::equal))
Allow breaking between type and name in for loops. This fixes llvm.org/PR15033. Also: Always break before a parameter, if the previous parameter was split over multiple lines. This was necessary to make the right decisions in for-loops, almost always makes the code more readable and also fixes llvm.org/PR14873. Before: for (llvm::ArrayRef<NamedDecl *>::iterator I = FD->getDeclsInPrototypeScope() .begin(), E = FD->getDeclsInPrototypeScope().end(); I != E; ++I) { } foo(bar(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb, ccccccccccccccccccccccccccccc), d, bar(e, f)); After: for (llvm::ArrayRef<NamedDecl *>::iterator I = FD->getDeclsInPrototypeScope().begin(), E = FD->getDeclsInPrototypeScope().end(); I != E; ++I) { } foo(bar(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb, ccccccccccccccccccccccccccccc), d, bar(e, f)); llvm-svn: 175741
2013-02-21 23:00:29 +08:00
return 4;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
// In Objective-C method expressions, prefer breaking before "param:" over
// breaking after it.
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Right.is(TT_SelectorName))
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return 0;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Left.is(tok::colon) && Left.is(TT_ObjCMethodExpr))
clang-format: Fix bug in ObjC method declaration formatting. Also disallow breaking between "@" and "{" or "[". Before: - (NSAttributedString *)attributedStringForSegment:(NSUInteger)segment index:(NSUInteger)index attributes:(NSDictionary *)attributes nonDigitAttributes:(NSDictionary *) nonDigitAttributes; [mailComposeViewController setToRecipients:@ [ NSBundle.mainBundle.infoDictionary[@"ABBFeedbackEmail"] ]]; After: - (NSAttributedString *)attributedStringForSegment:(NSUInteger)segment index:(NSUInteger)index attributes:(NSDictionary *)attributes nonDigitAttributes: (NSDictionary *)nonDigitAttributes; [mailComposeViewController setToRecipients: @[ NSBundle.mainBundle.infoDictionary[@"ABBFeedbackEmail"] ]]; This fixes llvm.org/PR18030. llvm-svn: 195550
2013-11-23 22:27:27 +08:00
return Line.MightBeFunctionDecl ? 50 : 500;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
[clang-format] Do not break after ObjC category open paren Summary: Previously, `clang-format` would break Objective-C category extensions after the opening parenthesis to avoid breaking the protocol list: ``` % echo "@interface ccccccccccccc (ccccccccccc) <ccccccccccccc> { }" | \ clang-format -assume-filename=foo.h -style="{BasedOnStyle: llvm, \ ColumnLimit: 40}" @interface ccccccccccccc ( ccccccccccc) <ccccccccccccc> { } ``` This looks fairly odd, as we could have kept the category extension on the previous line. Category extensions are a single item, so they are generally very short compared to protocol lists. We should prefer breaking after the opening `<` of the protocol list over breaking after the opening `(` of the category extension. With this diff, we now avoid breaking after the category extension's open paren, which causes us to break after the protocol list's open angle bracket: ``` % echo "@interface ccccccccccccc (ccccccccccc) <ccccccccccccc> { }" | \ ./bin/clang-format -assume-filename=foo.h -style="{BasedOnStyle: llvm, \ ColumnLimit: 40}" @interface ccccccccccccc (ccccccccccc) < ccccccccccccc> { } ``` Test Plan: New test added. Confirmed test failed before diff and passed after diff by running: % make -j16 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: djasper, jolesiak Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D45526 llvm-svn: 329919
2018-04-12 23:11:55 +08:00
// In Objective-C type declarations, avoid breaking after the category's
// open paren (we'll prefer breaking after the protocol list's opening
// angle bracket, if present).
if (Line.Type == LT_ObjCDecl && Left.is(tok::l_paren) && Left.Previous &&
Left.Previous->isOneOf(tok::identifier, tok::greater))
return 500;
clang-format: Add an additional value to AlignAfterOpenBracket: AlwaysBreak. Summary: If this option is set, clang-format will always insert a line wrap, e.g. before the first parameter of a function call unless all parameters fit on the same line. This obviates the need to make a decision on the alignment itself. Use this style for Google's JavaScript style and add some minor tweaks to correctly handle nested blocks etc. with it. Don't use this option for for/while loops. Reviewers: klimek Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D14104 llvm-svn: 251405
2015-10-27 20:38:37 +08:00
if (Left.is(tok::l_paren) && InFunctionDecl &&
Style.AlignAfterOpenBracket != FormatStyle::BAS_DontAlign)
Change clang-format's affinity for breaking after return types. Function declarations are now broken with the following preferences: 1) break amongst arguments. 2) break after return type. 3) break after (. 4) break before after nested name specifiers. Options #2 or #3 are preferred over #1 only if a substantial number of lines can be saved by that. llvm-svn: 179287
2013-04-11 22:29:13 +08:00
return 100;
clang-format: Break after "for (" less eagerly. Before: for ( auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa); aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb; ++aaaaaaaaaaaaaaaaaaaaaaaaaaa) { After: for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa( aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa); aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb; ++aaaaaaaaaaaaaaaaaaaaaaaaaaa) { llvm-svn: 241601
2015-07-08 00:09:39 +08:00
if (Left.is(tok::l_paren) && Left.Previous &&
clang-format clang-format. llvm-svn: 313744
2017-09-20 17:51:03 +08:00
(Left.Previous->isOneOf(tok::kw_if, tok::kw_for) ||
Left.Previous->endsSequence(tok::kw_constexpr, tok::kw_if)))
clang-format: Allow breaking after "else if(" as a last resort. This isn't generally nice, but better than violating the column limit. llvm-svn: 230620
2015-02-26 17:49:08 +08:00
return 1000;
clang-format: Break default arguments less eagerly. Before: void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1); After: void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa( int aaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1); llvm-svn: 198070
2013-12-27 14:39:56 +08:00
if (Left.is(tok::equal) && InFunctionDecl)
return 110;
clang-format: Prefer not to put lambdas on a single line. Before: string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() { SomeOtherFunctioooooooooooooooooooooooooon(); }); After: string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() { SomeOtherFunctioooooooooooooooooooooooooon(); }); llvm-svn: 215197
2014-08-08 20:00:13 +08:00
if (Right.is(tok::r_brace))
return 1;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Left.is(TT_TemplateOpener))
clang-format: Prefer breaking after return type over template param Before: typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa aaaaaaaaaa< aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bool *aaaaaaaaaaaaaaaaaa, bool *aa) {} After: typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa( bool *aaaaaaaaaaaaaaaaaa, bool *aa) {} llvm-svn: 215693
2014-08-15 13:00:39 +08:00
return 100;
clang-format: Add option to disable alignment after opening brackets Before: SomeFunction(parameter, parameter); After: SomeFunction(parameter, parameter); Patch by Harry Terkelsen, thank you! llvm-svn: 222284
2014-11-19 07:55:27 +08:00
if (Left.opensScope()) {
clang-format: Add an additional value to AlignAfterOpenBracket: AlwaysBreak. Summary: If this option is set, clang-format will always insert a line wrap, e.g. before the first parameter of a function call unless all parameters fit on the same line. This obviates the need to make a decision on the alignment itself. Use this style for Google's JavaScript style and add some minor tweaks to correctly handle nested blocks etc. with it. Don't use this option for for/while loops. Reviewers: klimek Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D14104 llvm-svn: 251405
2015-10-27 20:38:37 +08:00
if (Style.AlignAfterOpenBracket == FormatStyle::BAS_DontAlign)
clang-format: Add option to disable alignment after opening brackets Before: SomeFunction(parameter, parameter); After: SomeFunction(parameter, parameter); Patch by Harry Terkelsen, thank you! llvm-svn: 222284
2014-11-19 07:55:27 +08:00
return 0;
clang-format: tweak formatting of variable initialization blocks Summary: This patch changes the behavior of PenaltyBreakBeforeFirstCallParameter so that is does not apply after a brace, when Cpp11BracedListStyle is false. This way, variable initialization is wrapped more like an initializer than like a function call, which is more consistent with user expectations for this braced list style. With PenaltyBreakBeforeFirstCallParameter=200, this gives the following code: (with Cpp11BracedListStyle=false) Before : const std::unordered_map<std::string, int> Something::MyHashTable = { { "aaaaaaaaaaaaaaaaaaaaa", 0 }, { "bbbbbbbbbbbbbbbbbbbbb", 1 }, { "ccccccccccccccccccccc", 2 } }; After : const std::unordered_set<std::string> Something::MyUnorderedSet = { { "aaaaaaaaaaaaaaaaaaaaa", 0 }, { "bbbbbbbbbbbbbbbbbbbbb", 1 }, { "ccccccccccccccccccccc", 2 } }; Reviewers: krasimir, djasper, klimek Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D43290 llvm-svn: 332434
2018-05-16 16:03:52 +08:00
if (Left.is(tok::l_brace) && !Style.Cpp11BracedListStyle)
return 19;
clang-format: Adapt line break penalties for LLVM style. Specifically make clang-format less eager to break after the opening parenthesis of a function call. Before: aaaaaaaaaaaaaaaaa( aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa); After: aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa); Apparently that is preferable. This penalties are adapted conservatively, we might have to increase them a little bit further. llvm-svn: 193410
2013-10-25 22:29:37 +08:00
return Left.ParameterCount > 1 ? Style.PenaltyBreakBeforeFirstCallParameter
: 19;
clang-format: Add option to disable alignment after opening brackets Before: SomeFunction(parameter, parameter); After: SomeFunction(parameter, parameter); Patch by Harry Terkelsen, thank you! llvm-svn: 222284
2014-11-19 07:55:27 +08:00
}
clang-format: [Java] Prefer not to break in parameter annotations. Before: boolean someFunction(@Param(aaaaaaaaaaaaaaaa) String aaaaa, String bbbbbbbbbbbbbbb) {} After: boolean someFunction( @Param(aaaaaaaaaaaaaaaa) String aaaaa, String bbbbbbbbbbbbbbb) {} llvm-svn: 225971
2015-01-14 18:36:31 +08:00
if (Left.is(TT_JavaAnnotation))
return 50;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
clang-format: Keep string-literal-label + value pairs on a line. We have previously done that for <<-operators. This patch also adds this logic for "," and "+". Before: string v = "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa + "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa + "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa; string v = StrCat("aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa, "aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa, "aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa); After: string v = "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa + "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa + "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa; string v = StrCat("aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa, "aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa, "aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa); llvm-svn: 289531
2016-12-13 19:16:42 +08:00
if (Left.isOneOf(tok::plus, tok::comma) && Left.Previous &&
Left.Previous->isLabelString() &&
clang-format: Fix bug in understanding string-label&value analysis. While for <<-operators often used in log statments, a single key value pair is always on the second operator, e.g. llvm::errs() << "aaaaa=" << aaaaa; It is on the first operator for plus- or comma-concatenated strings: string s = "aaaaaaaaaa: " + aaaaaaaa; (the "=" not counting because that's a different operator precedence) llvm-svn: 290177
2016-12-20 23:27:46 +08:00
(Left.NextOperator || Left.OperatorIndex != 0))
[c++20] P0515R3: Parsing support and basic AST construction for operator <=>. Adding the new enumerator forced a bunch more changes into this patch than I would have liked. The -Wtautological-compare warning was extended to properly check the new comparison operator, clang-format needed updating because it uses precedence levels as weights for determining where to break lines (and several operators increased their precedence levels with this change), thread-safety analysis needed changes to build its own IL properly for the new operator. All "real" semantic checking for this operator has been deferred to a future patch. For now, we use the relational comparison rules and arbitrarily give the builtin form of the operator a return type of 'void'. llvm-svn: 320707
2017-12-14 23:16:18 +08:00
return 50;
clang-format: Fix bug in understanding string-label&value analysis. While for <<-operators often used in log statments, a single key value pair is always on the second operator, e.g. llvm::errs() << "aaaaa=" << aaaaa; It is on the first operator for plus- or comma-concatenated strings: string s = "aaaaaaaaaa: " + aaaaaaaa; (the "=" not counting because that's a different operator precedence) llvm-svn: 290177
2016-12-20 23:27:46 +08:00
if (Right.is(tok::plus) && Left.isLabelString() &&
(Right.NextOperator || Right.OperatorIndex != 0))
return 25;
clang-format: Keep string-literal-label + value pairs on a line. We have previously done that for <<-operators. This patch also adds this logic for "," and "+". Before: string v = "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa + "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa + "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa; string v = StrCat("aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa, "aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa, "aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa); After: string v = "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa + "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa + "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa; string v = StrCat("aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa, "aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa, "aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa); llvm-svn: 289531
2016-12-13 19:16:42 +08:00
if (Left.is(tok::comma))
return 1;
clang-format: Fix bug in understanding string-label&value analysis. While for <<-operators often used in log statments, a single key value pair is always on the second operator, e.g. llvm::errs() << "aaaaa=" << aaaaa; It is on the first operator for plus- or comma-concatenated strings: string s = "aaaaaaaaaa: " + aaaaaaaa; (the "=" not counting because that's a different operator precedence) llvm-svn: 290177
2016-12-20 23:27:46 +08:00
if (Right.is(tok::lessless) && Left.isLabelString() &&
clang-format: Keep string-literal-label + value pairs on a line. We have previously done that for <<-operators. This patch also adds this logic for "," and "+". Before: string v = "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa + "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa + "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa; string v = StrCat("aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa, "aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa, "aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa); After: string v = "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa + "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa + "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa; string v = StrCat("aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa, "aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa, "aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa); llvm-svn: 289531
2016-12-13 19:16:42 +08:00
(Right.NextOperator || Right.OperatorIndex != 1))
return 25;
clang-format: Slightly tweak the behavior of <<-wrapping. Before: SomeLongLoggingStatementOrMacro() << "Some long text " << some_variable << "\n"; Before: SomeLongLoggingStatementOrMacro() << "Some long text " << some_variable << "\n"; Short logging statements are already special cased in a different part of the code. llvm-svn: 290094
2016-12-19 19:14:23 +08:00
if (Right.is(tok::lessless)) {
// Breaking at a << is really cheap.
if (!Left.is(tok::r_paren) || Right.OperatorIndex > 0)
// Slightly prefer to break before the first one in log-like statements.
return 2;
return 1;
}
clang-format: Allow optimizer to break template declaration. Summary: Introduce `PenaltyBreakTemplateDeclaration` to control the penalty, and change `AlwaysBreakTemplateDeclarations` to an enum with 3 modes: * `No` for regular, penalty based, wrapping of template declaration * `MultiLine` for always wrapping before multi-line declarations (e.g. same as legacy behavior when `AlwaysBreakTemplateDeclarations=false`) * `Yes` for always wrapping (e.g. same as legacy behavior when `AlwaysBreakTemplateDeclarations=true`) Reviewers: krasimir, djasper, klimek Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D42684 llvm-svn: 332436
2018-05-16 16:25:03 +08:00
if (Left.ClosesTemplateDeclaration)
return Style.PenaltyBreakTemplateDeclaration;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Left.is(TT_ConditionalExpr))
Fix bad line break decision. Before: if (Intervals[i].getRange().getFirst() < Intervals[i - 1] .getRange().getLast()) {} After: if (Intervals[i].getRange().getFirst() < Intervals[i - 1].getRange().getLast()) {} llvm-svn: 176092
2013-02-26 21:59:14 +08:00
return prec::Conditional;
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
prec::Level Level = Left.getPrecedence();
clang-format: Allow customizing the penalty for breaking assignment Summary: Add option to customize the penalty for breaking assignment This allows increasing the priority of the assignment, to prefer spliting an operation instead of splitting the assignment, e.g. : int a = bbbbbbbbbbbbbbbb + cccccccccccccccc; Reviewers: krasimir, djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D32477 llvm-svn: 303534
2017-05-22 16:28:17 +08:00
if (Level == prec::Unknown)
Level = Right.getPrecedence();
if (Level == prec::Assignment)
return Style.PenaltyBreakAssignment;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
if (Level != prec::Unknown)
return Level;
Normal indent for last element of builder-type call. In builder type call, we indent to the laster function calls. However, for the last element of such a call, we don't need to do so, as that normally just wastes space and does not increase readability. Before: aaaaaa->aaaaaa->aaaaaa( // break aaaaaa); aaaaaaaaaaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaa ->aaaaaaaaaaaaaaaaaaaaaaaaaa( aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa); After: aaaaaa->aaaaaa->aaaaaa( // break aaaaaa); aaaaaaaaaaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaaaa( aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa); llvm-svn: 176352
2013-03-02 00:48:32 +08:00
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return 3;
}
Optionally derive formatting information from the input file. With this patch, clang-format can analyze the input file for two properties: 1. Is "int *a" or "int* a" more common. 2. Are non-C++03 constructs used, e.g. A<A<A>>. With Google-style, clang-format will now use the more common style for (1) and format C++03 compatible, unless it finds C++11 constructs in the input. llvm-svn: 174504
2013-02-06 22:22:40 +08:00
bool TokenAnnotator::spaceRequiredBetween(const AnnotatedLine &Line,
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
const FormatToken &Left,
const FormatToken &Right) {
clang-format: [JS] Keep space between 'return' and '['. llvm-svn: 208090
2014-05-06 22:12:21 +08:00
if (Left.is(tok::kw_return) && Right.isNot(tok::semi))
return true;
clang-format/java: Always put space after `assert` keyword. Previously, it was missing if the expression after the assert started with a (. llvm-svn: 314172
2017-09-26 06:42:49 +08:00
if (Left.is(Keywords.kw_assert) && Style.Language == FormatStyle::LK_Java)
return true;
clang-format: Add support for a space after @property Mozilla and WebKit seem to use a space after @property (verified by grepping their codebases) so we turn this on there as well. Change by Christian Legnitto. Thank you! llvm-svn: 200320
2014-01-28 23:20:33 +08:00
if (Style.ObjCSpaceAfterProperty && Line.Type == LT_ObjCProperty &&
Left.Tok.getObjCKeywordID() == tok::objc_property)
return true;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
if (Right.is(tok::hashhash))
return Left.is(tok::hash);
Added AnnotatedToken::isOneOf + a few other refactorings Summary: <subj> Reviewers: djasper Reviewed By: djasper CC: cfe-commits, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D536 llvm-svn: 176951
2013-03-13 22:41:29 +08:00
if (Left.isOneOf(tok::hashhash, tok::hash))
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return Right.is(tok::hash);
clang-format: Additional options for spaces around parentheses. This patch adds four new options to control: - Spaces after control keyworks (if(..) vs if (..)) - Spaces in empty parentheses (f( ) vs f()) - Spaces in c-style casts (( int )1.0 vs (int)1.0) - Spaces in other parentheses (f(a) vs f( a )) Patch by Joe Hermaszewski. Thank you for working on this! llvm-svn: 188793
2013-08-20 20:36:34 +08:00
if (Left.is(tok::l_paren) && Right.is(tok::r_paren))
return Style.SpaceInEmptyParentheses;
if (Left.is(tok::l_paren) || Right.is(tok::r_paren))
clang-format: [Java] Support formatting qualified annotations. llvm-svn: 225559
2015-01-10 07:25:06 +08:00
return (Right.is(TT_CastRParen) ||
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
(Left.MatchingParen && Left.MatchingParen->is(TT_CastRParen)))
clang-format: Additional options for spaces around parentheses. This patch adds four new options to control: - Spaces after control keyworks (if(..) vs if (..)) - Spaces in empty parentheses (f( ) vs f()) - Spaces in c-style casts (( int )1.0 vs (int)1.0) - Spaces in other parentheses (f(a) vs f( a )) Patch by Joe Hermaszewski. Thank you for working on this! llvm-svn: 188793
2013-08-20 20:36:34 +08:00
? Style.SpacesInCStyleCastParentheses
: Style.SpacesInParentheses;
if (Right.isOneOf(tok::semi, tok::comma))
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return false;
[clang-format] Don't insert space between ObjC class and lightweight generic Summary: In D45185, I added clang-format parser support for Objective-C generics. However, I didn't touch the whitespace logic, so they got the same space logic as Objective-C protocol lists. In every example in the Apple SDK and in the documentation, there is no space between the class name and the opening `<` for the lightweight generic specification, so this diff removes the space and updates the tests. Test Plan: Tests updated. Ran tests with: % make -j16 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: djasper, jolesiak Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D45498 llvm-svn: 329917
2018-04-12 23:11:51 +08:00
if (Right.is(tok::less) && Line.Type == LT_ObjCDecl) {
bool IsLightweightGeneric =
Right.MatchingParen && Right.MatchingParen->Next &&
Right.MatchingParen->Next->is(tok::colon);
return !IsLightweightGeneric && Style.ObjCSpaceBeforeProtocolList;
}
clang-format: Add SpaceAfterTemplate Summary: This is required for compliance with the Mozilla style guide. This is a rebase+minor change of Birunthan Mohanathas's patch Reviewers: djasper Subscribers: klimek, cfe-commits, opilarium Differential Revision: https://reviews.llvm.org/D23317 llvm-svn: 278121
2016-08-09 22:24:40 +08:00
if (Right.is(tok::less) && Left.is(tok::kw_template))
return Style.SpaceAfterTemplateKeyword;
Added AnnotatedToken::isOneOf + a few other refactorings Summary: <subj> Reviewers: djasper Reviewed By: djasper CC: cfe-commits, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D536 llvm-svn: 176951
2013-03-13 22:41:29 +08:00
if (Left.isOneOf(tok::exclaim, tok::tilde))
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return false;
if (Left.is(tok::at) &&
Added AnnotatedToken::isOneOf + a few other refactorings Summary: <subj> Reviewers: djasper Reviewed By: djasper CC: cfe-commits, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D536 llvm-svn: 176951
2013-03-13 22:41:29 +08:00
Right.isOneOf(tok::identifier, tok::string_literal, tok::char_constant,
tok::numeric_constant, tok::l_paren, tok::l_brace,
tok::kw_true, tok::kw_false))
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return false;
clang-format: [Proto] Basic support for options with <> for repeated fields. llvm-svn: 256737
2016-01-04 15:28:12 +08:00
if (Left.is(tok::colon))
return !Left.is(TT_ObjCMethodExpr);
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
if (Left.is(tok::coloncolon))
return false;
[clang-format] Adds space around angle brackets in text protos Summary: This patch adds spaces around angle brackets in text proto Google style. Previously these were detected as template openers and closers, which happened to have the expected effect. Now we detect them as scope openers and closers similarly to the way braces are handled in this context. Reviewers: djasper Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D42727 llvm-svn: 324337
2018-02-06 19:34:34 +08:00
if (Left.is(tok::less) || Right.isOneOf(tok::greater, tok::less)) {
if (Style.Language == FormatStyle::LK_TextProto ||
(Style.Language == FormatStyle::LK_Proto &&
(Left.is(TT_DictLiteral) || Right.is(TT_DictLiteral)))) {
// Format empty list as `<>`.
if (Left.is(tok::less) && Right.is(tok::greater))
return false;
return !Style.Cpp11BracedListStyle;
}
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return false;
[clang-format] Adds space around angle brackets in text protos Summary: This patch adds spaces around angle brackets in text proto Google style. Previously these were detected as template openers and closers, which happened to have the expected effect. Now we detect them as scope openers and closers similarly to the way braces are handled in this context. Reviewers: djasper Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D42727 llvm-svn: 324337
2018-02-06 19:34:34 +08:00
}
Don't add an extra space before ellipsis after pointers. Before (for styles where the pointer binds to the type): template <class... Ts> void Foo(Ts... ts) {} template <class... Ts> void Foo(Ts* ... ts) {} After: template <class... Ts> void Foo(Ts... ts) {} template <class... Ts> void Foo(Ts*... ts) {} llvm-svn: 185321
2013-07-01 17:47:25 +08:00
if (Right.is(tok::ellipsis))
clang-format: Fix enumerator case ranges. Before: case a... b: break; After: case a ... b: break; llvm-svn: 270027
2016-05-19 14:19:17 +08:00
return Left.Tok.isLiteral() || (Left.is(tok::identifier) && Left.Previous &&
Left.Previous->is(tok::kw_case));
Fix layout of lambda captures. Before: int c = [ &, &a, a]{ [ =, c, &d]{ return b++; }(); }(); After: int c = [&, &a, a] { [=, c, &d] { return b++; }(); }(); llvm-svn: 189924
2013-09-04 16:20:47 +08:00
if (Left.is(tok::l_square) && Right.is(tok::amp))
return false;
clang-format: Fix left pointer alignment after delctype/typeof Change 272124* introduced a regression in spaceRequiredBetween for left aligned pointers to decltype and typeof expressions. This fix adds logic to fix this. The test added is based on a related test in determineStarAmpUsage. Also add test cases for the regression. http://llvm.org/viewvc/llvm-project?view=revision&revision=272124 LLVM bug tracker: https://bugs.llvm.org/show_bug.cgi?id=30407 Differential revision: https://reviews.llvm.org/D35847 Fix contributed by euhlmann! llvm-svn: 310831
2017-08-14 19:06:07 +08:00
if (Right.is(TT_PointerOrReference)) {
if (Left.is(tok::r_paren) && Line.MightBeFunctionDecl) {
if (!Left.MatchingParen)
return true;
FormatToken *TokenBeforeMatchingParen =
Left.MatchingParen->getPreviousNonComment();
if (!TokenBeforeMatchingParen ||
!TokenBeforeMatchingParen->isOneOf(tok::kw_typeof, tok::kw_decltype))
return true;
}
return (Left.Tok.isLiteral() ||
clang-format: Fix spacing for function with ref-qualification .. .. when using SpacesInCStyleCastParentheses != SpacesInParentheses. Before: FormatStyle Spaces = getLLVMStyle(); Deleted &operator=(const Deleted &)& = default; Spaces.SpacesInParentheses = true; Deleted(const Deleted &)& = default; Spaces.SpacesInCStyleCastParentheses = true; Spaces.SpacesInParentheses= false; Deleted( const Deleted & )& = default; After: FormatStyle Spaces = getLLVMStyle(); Deleted &operator=(const Deleted &)& = default;; Spaces.SpacesInParentheses= true; Deleted( const Deleted & )& = default; Spaces.SpacesInCStyleCastParentheses = true; Spaces.SpacesInParentheses= false; Deleted(const Deleted &)& = default; Patch by Jean-Philippe Dufraigne. Thank you! llvm-svn: 230473
2015-02-25 18:30:06 +08:00
(!Left.isOneOf(TT_PointerOrReference, tok::l_paren) &&
clang-format: Always align */& in multi-var DeclStmts. Seems like the most consistent thing to do and in multi-var DeclStmts, it is especially important to point out that the */& bind to the identifier. llvm-svn: 230903
2015-03-02 02:55:26 +08:00
(Style.PointerAlignment != FormatStyle::PAS_Left ||
clang-format: Fix bad multi-variable for-loop formatting. Before: for (int*p, *q; p != q; p = p->next) { After: for (int *p, *q; p != q; p = p->next) { llvm-svn: 283246
2016-10-05 04:18:25 +08:00
(Line.IsMultiVariableDeclStmt &&
(Left.NestingLevel == 0 ||
(Left.NestingLevel == 1 && Line.First->is(tok::kw_for)))))));
clang-format: Fix left pointer alignment after delctype/typeof Change 272124* introduced a regression in spaceRequiredBetween for left aligned pointers to decltype and typeof expressions. This fix adds logic to fix this. The test added is based on a related test in determineStarAmpUsage. Also add test cases for the regression. http://llvm.org/viewvc/llvm-project?view=revision&revision=272124 LLVM bug tracker: https://bugs.llvm.org/show_bug.cgi?id=30407 Differential revision: https://reviews.llvm.org/D35847 Fix contributed by euhlmann! llvm-svn: 310831
2017-08-14 19:06:07 +08:00
}
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Right.is(TT_FunctionTypeLParen) && Left.isNot(tok::l_paren) &&
(!Left.is(TT_PointerOrReference) ||
clang-format: Always align */& in multi-var DeclStmts. Seems like the most consistent thing to do and in multi-var DeclStmts, it is especially important to point out that the */& bind to the identifier. llvm-svn: 230903
2015-03-02 02:55:26 +08:00
(Style.PointerAlignment != FormatStyle::PAS_Right &&
!Line.IsMultiVariableDeclStmt)))
Fix formatting of pointers to members. Before: int(S::*func)(void *); After: int (S::*func)(void *); llvm-svn: 181438
2013-05-08 22:58:20 +08:00
return true;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Left.is(TT_PointerOrReference))
clang-format: Improve support for override/final as variable names. Before: bool a = f() &&override.f(); bool a = f() &&final.f(); void f(const MyOverride & override); void f(const MyFinal & final); After: bool a = f() && override.f(); bool a = f() && final.f(); void f(const MyOverride &override); void f(const MyFinal &final); llvm-svn: 291434
2017-01-09 19:04:07 +08:00
return Right.Tok.isLiteral() || Right.is(TT_BlockComment) ||
(Right.isOneOf(Keywords.kw_override, Keywords.kw_final) &&
!Right.is(TT_StartOfName)) ||
clang-format: Always add space before lambda-{ Before: int c = []() -> int *{ return 2; }(); After: int c = []() -> int * { return 2; }(); Based on patch by James Dennett (http://reviews.llvm.org/D10410), thank you! llvm-svn: 239600
2015-06-12 17:59:16 +08:00
(Right.is(tok::l_brace) && Right.BlockKind == BK_Block) ||
clang-format: Don't add unwanted space when creating new arrays. Before: char** newargv = new char* [argc]; After: char** newargv = new char*[argc]; llvm-svn: 235583
2015-04-23 18:23:53 +08:00
(!Right.isOneOf(TT_PointerOrReference, TT_ArraySubscriptLSquare,
tok::l_paren) &&
clang-format: Always align */& in multi-var DeclStmts. Seems like the most consistent thing to do and in multi-var DeclStmts, it is especially important to point out that the */& bind to the identifier. llvm-svn: 230903
2015-03-02 02:55:26 +08:00
(Style.PointerAlignment != FormatStyle::PAS_Right &&
!Line.IsMultiVariableDeclStmt) &&
Left.Previous &&
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
!Left.Previous->isOneOf(tok::l_paren, tok::coloncolon));
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
if (Right.is(tok::star) && Left.is(tok::l_paren))
return false;
[clang-format] Support repeated field lists in protos Summary: This patch adds support for list initialization of proto repeated fields: ``` keys: [1, 2, 3] ``` Reviewers: djasper Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D43298 llvm-svn: 325252
2018-02-15 23:30:22 +08:00
const auto SpaceRequiredForArrayInitializerLSquare =
[](const FormatToken &LSquareTok, const FormatStyle &Style) {
return Style.SpacesInContainerLiterals ||
((Style.Language == FormatStyle::LK_Proto ||
Style.Language == FormatStyle::LK_TextProto) &&
!Style.Cpp11BracedListStyle &&
LSquareTok.endsSequence(tok::l_square, tok::colon,
TT_SelectorName));
};
Formatter: Detect ObjC array literals. Use this to add a space after "@[" and before "]" for now. Later, I want to use this to format multi-line array literals nicer, too. llvm-svn: 174822
2013-02-10 10:08:05 +08:00
if (Left.is(tok::l_square))
[clang-format] Support repeated field lists in protos Summary: This patch adds support for list initialization of proto repeated fields: ``` keys: [1, 2, 3] ``` Reviewers: djasper Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D43298 llvm-svn: 325252
2018-02-15 23:30:22 +08:00
return (Left.is(TT_ArrayInitializerLSquare) && Right.isNot(tok::r_square) &&
SpaceRequiredForArrayInitializerLSquare(Left, Style)) ||
[clang-format] Add support for C++17 structured bindings. Summary: Before: ``` auto[a, b] = f(); ``` After: ``` auto [a, b] = f(); ``` or, if SpacesInSquareBrackets is true: ``` auto [ a, b ] = f(); ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D37132 llvm-svn: 312723
2017-09-07 22:28:32 +08:00
(Left.isOneOf(TT_ArraySubscriptLSquare,
TT_StructuredBindingLSquare) &&
Style.SpacesInSquareBrackets && Right.isNot(tok::r_square));
Formatter: Detect ObjC array literals. Use this to add a space after "@[" and before "]" for now. Later, I want to use this to format multi-line array literals nicer, too. llvm-svn: 174822
2013-02-10 10:08:05 +08:00
if (Right.is(tok::r_square))
clang-format: New option SpacesInSquareBrackets. Before: int a[5]; a[3] += 42; After: int a[ 5 ]; a[ 3 ] += 42; Fixes LLVM bug #17887 (http://llvm.org/bugs/show_bug.cgi?id=17887). Patch by Marek Kurdej, thank you! llvm-svn: 216449
2014-08-26 19:41:14 +08:00
return Right.MatchingParen &&
[clang-format] Support repeated field lists in protos Summary: This patch adds support for list initialization of proto repeated fields: ``` keys: [1, 2, 3] ``` Reviewers: djasper Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D43298 llvm-svn: 325252
2018-02-15 23:30:22 +08:00
((Right.MatchingParen->is(TT_ArrayInitializerLSquare) &&
SpaceRequiredForArrayInitializerLSquare(*Right.MatchingParen,
Style)) ||
clang-format: New option SpacesInSquareBrackets. Before: int a[5]; a[3] += 42; After: int a[ 5 ]; a[ 3 ] += 42; Fixes LLVM bug #17887 (http://llvm.org/bugs/show_bug.cgi?id=17887). Patch by Marek Kurdej, thank you! llvm-svn: 216449
2014-08-26 19:41:14 +08:00
(Style.SpacesInSquareBrackets &&
[clang-format] Add support for C++17 structured bindings. Summary: Before: ``` auto[a, b] = f(); ``` After: ``` auto [a, b] = f(); ``` or, if SpacesInSquareBrackets is true: ``` auto [ a, b ] = f(); ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D37132 llvm-svn: 312723
2017-09-07 22:28:32 +08:00
Right.MatchingParen->isOneOf(TT_ArraySubscriptLSquare,
[clang-format] Don't detect C++11 attribute specifiers as ObjC Summary: Previously, clang-format would detect C++11 and C++17 attribute specifiers like the following as Objective-C method invocations: [[noreturn]]; [[clang::fallthrough]]; [[noreturn, deprecated("so sorry")]]; [[using gsl: suppress("type")]]; To fix this, I ported part of the logic from tools/clang/lib/Parse/ParseTentative.cpp into TokenAnnotator.cpp so we can explicitly parse and identify C++11 attribute specifiers. This allows the guessLanguage() and getStyle() APIs to correctly guess files containing the C++11 attribute specifiers as C++, not Objective-C. Test Plan: New tests added. Ran tests with: make -j12 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: krasimir, jolesiak, djasper Reviewed By: djasper Subscribers: aaron.ballman, cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D43902 llvm-svn: 327284
2018-03-12 23:42:38 +08:00
TT_StructuredBindingLSquare)) ||
Right.MatchingParen->is(TT_AttributeParen));
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Right.is(tok::l_square) &&
clang-format: Fix C99 designated initializers corner cases Summary: This fixes the missing space before the designated initializer when `Cpp11BracedListStyle=false` : const struct A a = { .a = 1, .b = 2 }; ^ Also, wrapping between opening brace and designated array initializers used to have an excessive penalty (like breaking between an expression and the subscript operator), leading to unexpected wrapping: const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {[1] = aaaaaaaaaaaaaaaaaaaaaaaaaaa, [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbb}; instead of: const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = { [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaa, [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbb}; Finally, designated array initializers are not binpacked, just like designated member initializers. Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, krasimir, klimek Differential Revision: https://reviews.llvm.org/D33491 llvm-svn: 305696
2017-06-19 22:41:21 +08:00
!Right.isOneOf(TT_ObjCMethodExpr, TT_LambdaLSquare,
[clang-format] Add support for C++17 structured bindings. Summary: Before: ``` auto[a, b] = f(); ``` After: ``` auto [a, b] = f(); ``` or, if SpacesInSquareBrackets is true: ``` auto [ a, b ] = f(); ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D37132 llvm-svn: 312723
2017-09-07 22:28:32 +08:00
TT_DesignatedInitializerLSquare,
[clang-format] Don't detect C++11 attribute specifiers as ObjC Summary: Previously, clang-format would detect C++11 and C++17 attribute specifiers like the following as Objective-C method invocations: [[noreturn]]; [[clang::fallthrough]]; [[noreturn, deprecated("so sorry")]]; [[using gsl: suppress("type")]]; To fix this, I ported part of the logic from tools/clang/lib/Parse/ParseTentative.cpp into TokenAnnotator.cpp so we can explicitly parse and identify C++11 attribute specifiers. This allows the guessLanguage() and getStyle() APIs to correctly guess files containing the C++11 attribute specifiers as C++, not Objective-C. Test Plan: New tests added. Ran tests with: make -j12 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: krasimir, jolesiak, djasper Reviewed By: djasper Subscribers: aaron.ballman, cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D43902 llvm-svn: 327284
2018-03-12 23:42:38 +08:00
TT_StructuredBindingLSquare, TT_AttributeSquare) &&
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
!Left.isOneOf(tok::numeric_constant, TT_DictLiteral))
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return false;
clang-format: Improve handling of block comments in braced lists. Before: std::vector<int> v = { 1, 0 /* comment */ }; After: std::vector<int> v = {1, 0 /* comment */}; llvm-svn: 216445
2014-08-26 17:37:52 +08:00
if (Left.is(tok::l_brace) && Right.is(tok::r_brace))
return !Left.Children.empty(); // No spaces in "{}".
if ((Left.is(tok::l_brace) && Left.BlockKind != BK_Block) ||
(Right.is(tok::r_brace) && Right.MatchingParen &&
Right.MatchingParen->BlockKind != BK_Block))
return !Style.Cpp11BracedListStyle;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Left.is(TT_BlockComment))
clang-format: [JS] Keep space after closure style comments. Before: var x = /** @type {foo} */ (bar); After: var x = /** @type {foo} */(bar); llvm-svn: 208093
2014-05-06 22:41:29 +08:00
return !Left.TokenText.endswith("=*/");
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
if (Right.is(tok::l_paren)) {
[clang-format] Don't detect C++11 attribute specifiers as ObjC Summary: Previously, clang-format would detect C++11 and C++17 attribute specifiers like the following as Objective-C method invocations: [[noreturn]]; [[clang::fallthrough]]; [[noreturn, deprecated("so sorry")]]; [[using gsl: suppress("type")]]; To fix this, I ported part of the logic from tools/clang/lib/Parse/ParseTentative.cpp into TokenAnnotator.cpp so we can explicitly parse and identify C++11 attribute specifiers. This allows the guessLanguage() and getStyle() APIs to correctly guess files containing the C++11 attribute specifiers as C++, not Objective-C. Test Plan: New tests added. Ran tests with: make -j12 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: krasimir, jolesiak, djasper Reviewed By: djasper Subscribers: aaron.ballman, cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D43902 llvm-svn: 327284
2018-03-12 23:42:38 +08:00
if ((Left.is(tok::r_paren) && Left.is(TT_AttributeParen)) ||
(Left.is(tok::r_square) && Left.is(TT_AttributeSquare)))
clang-format: Add space in corner case. Before: SomeType s __attribute__((unused))(InitValue); After: SomeType s __attribute__((unused)) (InitValue); llvm-svn: 186535
2013-07-18 04:25:02 +08:00
return true;
clang-format: [JS] new and delete are valid function names. Before: someObject.new (); someObject.delete (); After: someObject.new(); someObject.delete(); llvm-svn: 222890
2014-11-27 22:55:17 +08:00
return Line.Type == LT_ObjCDecl || Left.is(tok::semi) ||
Support GNU style rule to put a space before opening parenthesis. Summary: The rule from the GNU style states: "We find it easier to read a program when it has spaces before the open-parentheses and after the commas." http://www.gnu.org/prep/standards/standards.html#index-spaces-before-open_002dparen This patch makes clang-format adds an option to put spaces before almost all open parentheses, except the cases, where different behavior is dictated by the style rules or language syntax: * preprocessor: ** function-like macro definitions can't have a space between the macro name and the parenthesis; ** `#if defined(...)` can have a space, but it seems, that it's more frequently used without a space in GCC, for example; * never add spaces after unary operators; * adding spaces between two opening parentheses is controlled with the `SpacesInParentheses` option; * never add spaces between `[` and `(` (there's no option yet). Reviewers: djasper Reviewed By: djasper CC: cfe-commits, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D2326 llvm-svn: 196901
2013-12-10 18:18:34 +08:00
(Style.SpaceBeforeParens != FormatStyle::SBPO_Never &&
clang-format: Don't remove space between #elif and parentheses. Before: #elif(AAAA && BBBB) After: #elif (AAAA && BBBB) llvm-svn: 245043
2015-08-14 20:44:06 +08:00
(Left.isOneOf(tok::kw_if, tok::pp_elif, tok::kw_for, tok::kw_while,
clang-format: Fixed missing space between Obj-C for/in and a typecast. Fixes this bug: https://llvm.org/bugs/show_bug.cgi?id=24504 TokenAnnotator::spaceRequiredBetween was handling TT_ForEachMacro but not TT_ObjCForIn, so lines that look like: for (id nextObject in (NSArray *)myArray) would incorrectly turn into: for (id nextObject in(NSArray *)myArray) Patch by Kent Sutherland, thank you. llvm-svn: 249553
2015-10-07 23:09:08 +08:00
tok::kw_switch, tok::kw_case, TT_ForEachMacro,
TT_ObjCForIn) ||
clang-format: Handle "if constexpr". c++1z adds the following constructions to the language: if constexpr (cond) statement1; else if constexpr (cond) statement2; else if constexpr (cond) statement3; else statement4; A first version of this was proposed in reviews.llvm.org/D26953 by Francis Visoiu Mistrih, but never commited. This patch additionally fixes the behavior when allowing short if statements on a single line and was authored by Jacob Bandes-Storch. Thank you to both authors. llvm-svn: 305666
2017-06-19 15:40:49 +08:00
Left.endsSequence(tok::kw_constexpr, tok::kw_if) ||
clang-format: Add support for SEH __try / __except / __finally blocks. This lets clang-format format __try { } __except(0) { } and __try { } __finally { } correctly. __try and __finally are keywords if `LangOpts.MicrosoftExt` is set, so this turns this on. This also enables a few other keywords, but it shouldn't overly perturb regular clang-format operation. __except is a context-sensitive keyword, so `AdditionalKeywords` needs to be passed around to a few more places. Fixes PR22321. llvm-svn: 228148
2015-02-04 23:26:27 +08:00
(Left.isOneOf(tok::kw_try, Keywords.kw___except, tok::kw_catch,
tok::kw_new, tok::kw_delete) &&
clang-format: NFC: Delete FormatToken::IsForEachMacro. Use a TokenType instead. llvm-svn: 236415
2015-05-04 17:22:29 +08:00
(!Left.Previous || Left.Previous->isNot(tok::period))))) ||
Support GNU style rule to put a space before opening parenthesis. Summary: The rule from the GNU style states: "We find it easier to read a program when it has spaces before the open-parentheses and after the commas." http://www.gnu.org/prep/standards/standards.html#index-spaces-before-open_002dparen This patch makes clang-format adds an option to put spaces before almost all open parentheses, except the cases, where different behavior is dictated by the style rules or language syntax: * preprocessor: ** function-like macro definitions can't have a space between the macro name and the parenthesis; ** `#if defined(...)` can have a space, but it seems, that it's more frequently used without a space in GCC, for example; * never add spaces after unary operators; * adding spaces between two opening parentheses is controlled with the `SpacesInParentheses` option; * never add spaces between `[` and `(` (there's no option yet). Reviewers: djasper Reviewed By: djasper CC: cfe-commits, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D2326 llvm-svn: 196901
2013-12-10 18:18:34 +08:00
(Style.SpaceBeforeParens == FormatStyle::SBPO_Always &&
clang-format: clang-format (NFC) llvm-svn: 239903
2015-06-17 21:08:06 +08:00
(Left.is(tok::identifier) || Left.isFunctionLikeKeyword() ||
Left.is(tok::r_paren)) &&
Support GNU style rule to put a space before opening parenthesis. Summary: The rule from the GNU style states: "We find it easier to read a program when it has spaces before the open-parentheses and after the commas." http://www.gnu.org/prep/standards/standards.html#index-spaces-before-open_002dparen This patch makes clang-format adds an option to put spaces before almost all open parentheses, except the cases, where different behavior is dictated by the style rules or language syntax: * preprocessor: ** function-like macro definitions can't have a space between the macro name and the parenthesis; ** `#if defined(...)` can have a space, but it seems, that it's more frequently used without a space in GCC, for example; * never add spaces after unary operators; * adding spaces between two opening parentheses is controlled with the `SpacesInParentheses` option; * never add spaces between `[` and `(` (there's no option yet). Reviewers: djasper Reviewed By: djasper CC: cfe-commits, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D2326 llvm-svn: 196901
2013-12-10 18:18:34 +08:00
Line.Type != LT_PreprocessorDirective);
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
}
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
if (Left.is(tok::at) && Right.Tok.getObjCKeywordID() != tok::objc_not_keyword)
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return false;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Right.is(TT_UnaryOperator))
Improve formatting of braced lists. Before: vector<int> v{ -1}; After: vector<int> v{-1}; llvm-svn: 182597
2013-05-24 02:05:18 +08:00
return !Left.isOneOf(tok::l_paren, tok::l_square, tok::at) &&
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
(Left.isNot(tok::colon) || Left.isNot(TT_ObjCMethodExpr));
clang-format: No space between ")" and braced init list. Before: auto j = decltype(i) {}; After: auto j = decltype(i){}; This fixes llvm.org/PR19892. llvm-svn: 210013
2014-06-02 18:57:55 +08:00
if ((Left.isOneOf(tok::identifier, tok::greater, tok::r_square,
tok::r_paren) ||
clang-format: Fix bad space before braced initializer. Before: new int {1}; After: new int{1}; llvm-svn: 208168
2014-05-07 15:59:03 +08:00
Left.isSimpleTypeSpecifier()) &&
Fix layout of lambda captures. Before: int c = [ &, &a, a]{ [ =, c, &d]{ return b++; }(); }(); After: int c = [&, &a, a] { [=, c, &d] { return b++; }(); }(); llvm-svn: 189924
2013-09-04 16:20:47 +08:00
Right.is(tok::l_brace) && Right.getNextNonComment() &&
Right.BlockKind != BK_Block)
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return false;
Initial support for designated initializers. llvm-svn: 182767
2013-05-28 19:30:49 +08:00
if (Left.is(tok::period) || Right.is(tok::period))
return false;
Don't divide L and #x in macro definitions. Fixes http://llvm.org/PR17144 Reviewers: djasper Reviewed By: djasper CC: cfe-commits, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D1639 llvm-svn: 190408
2013-09-10 21:41:43 +08:00
if (Right.is(tok::hash) && Left.is(tok::identifier) && Left.TokenText == "L")
return false;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Left.is(TT_TemplateCloser) && Left.MatchingParen &&
clang-format: [Java] Fix space in generic method calls. Before: A.<B>doSomething(); After: A.<B>doSomething(); llvm-svn: 220285
2014-10-21 19:13:31 +08:00
Left.MatchingParen->Previous &&
Left.MatchingParen->Previous->is(tok::period))
clang-format/java: Unbreak genenrics formatting after r299952. https://reviews.llvm.org/rL299952 merged '>>>' tokens into a single JavaRightLogicalShift token. This broke formatting of generics nested more than two deep, e.g. Foo<Bar<Baz>>> because the '>>>' now weren't three '>' for parseAngle(). Luckily, just deleting JavaRightLogicalShift fixes things without breaking the test added in r299952, so do that. https://reviews.llvm.org/D38291 llvm-svn: 314325
2017-09-28 01:57:50 +08:00
// A.<B<C<...>>>DoSomething();
clang-format: [Java] Fix space in generic method calls. Before: A.<B>doSomething(); After: A.<B>doSomething(); llvm-svn: 220285
2014-10-21 19:13:31 +08:00
return false;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Left.is(TT_TemplateCloser) && Right.is(tok::l_square))
clang-format: Fix space between generic type parameter and square bracket Before: public Foo<X, Y> [] foos; After: public Foo<X, Y>[] foos; Patch by Harry Terkelsen. Thank you! llvm-svn: 222283
2014-11-19 07:48:01 +08:00
return false;
[clang-format/ObjC] Do not insert space after opening brace of ObjC dict literal Summary: D44816 attempted to fix a few cases where `clang-format` incorrectly inserted a space before the closing brace of an Objective-C dictionary literal. This revealed there were still a few cases where we inserted a space after the opening brace of an Objective-C dictionary literal. This fixes the formatting to be consistent and adds more tests. Test Plan: New tests added. Confirmed tests failed before diff and passed after diff. Ran tests with: % make -j12 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: djasper, jolesiak, krasimir Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D45168 llvm-svn: 329069
2018-04-03 22:07:09 +08:00
if (Left.is(tok::l_brace) && Left.endsSequence(TT_DictLiteral, tok::at))
// Objective-C dictionary literal -> no space after opening brace.
return false;
[clang-format] Do not insert space before closing brace in ObjC dict literal Summary: Previously, `clang-format` would sometimes insert a space before the closing brace in an Objective-C dictionary literal. Unlike array literals (which obey `Style.SpacesInContainerLiterals` to add a space after `[` and before `]`), Objective-C dictionary literals currently are not meant to insert a space after `{` and before `}`, regardless of `Style.SpacesInContainerLiterals`. However, some constructs like `@{foo : @(bar)}` caused `clang-format` to insert a space between `)` and `}`. This fixes the issue and adds tests. (I understand the behavior is not consistent between array literals and dictionary literals, but that's existing behavior that's a much larger change.) Test Plan: New tests added. Ran tests with: % make -j12 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: djasper, jolesiak, Wizard Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D44816 llvm-svn: 328627
2018-03-27 23:01:17 +08:00
if (Right.is(tok::r_brace) && Right.MatchingParen &&
Right.MatchingParen->endsSequence(TT_DictLiteral, tok::at))
// Objective-C dictionary literal -> no space before closing brace.
return false;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return true;
}
Optionally derive formatting information from the input file. With this patch, clang-format can analyze the input file for two properties: 1. Is "int *a" or "int* a" more common. 2. Are non-C++03 constructs used, e.g. A<A<A>>. With Google-style, clang-format will now use the more common style for (1) and format C++03 compatible, unless it finds C++11 constructs in the input. llvm-svn: 174504
2013-02-06 22:22:40 +08:00
bool TokenAnnotator::spaceRequiredBefore(const AnnotatedLine &Line,
clang-format: Fix space in direct destructor calls. Before: void F(int& i) { i. ~int(); } After: void F(int& i) { i.~int(); } Also, some cleanups. llvm-svn: 220269
2014-10-21 15:51:54 +08:00
const FormatToken &Right) {
const FormatToken &Left = *Right.Previous;
clang-format: [Proto] Don't treat "operator" as keyword. Before: optional string operator= 1; After: optional string operator = 1; llvm-svn: 240624
2015-06-25 16:38:46 +08:00
if (Right.Tok.getIdentifierInfo() && Left.Tok.getIdentifierInfo())
return true; // Never ever merge two identifiers.
clang-format: Fix post-commit review comment of r299204, use Style.isCpp(). Also, while at it, s/IsCpp/isCpp/ so that it follows LLVM style. llvm-svn: 299214
2017-03-31 21:30:24 +08:00
if (Style.isCpp()) {
clang-format: [Proto] Don't treat "operator" as keyword. Before: optional string operator= 1; After: optional string operator = 1; llvm-svn: 240624
2015-06-25 16:38:46 +08:00
if (Left.is(tok::kw_operator))
return Right.is(tok::coloncolon);
[clang-format] Add SpaceBeforeCpp11BracedList option. WebKit C++ style for object initialization is as follows: Foo foo { bar }; Yet using clang-format -style=webkit changes this to: Foo foo{ bar }; As there is no existing combination of rules that will ensure a space before a braced list in this fashion, this patch adds a new SpaceBeforeCpp11BracedList rule. Patch by Ross Kirsling! Differential Revision: https://reviews.llvm.org/D46024 llvm-svn: 334692
2018-06-14 16:01:09 +08:00
if (Right.is(tok::l_brace) && Right.BlockKind == BK_BracedInit &&
!Left.opensScope() && Style.SpaceBeforeCpp11BracedList)
return true;
[clang-format] Support text proto messages Summary: This patch adds support for textual protocol buffer messages. Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek, mgorny Differential Revision: https://reviews.llvm.org/D34441 llvm-svn: 307029
2017-07-03 23:05:14 +08:00
} else if (Style.Language == FormatStyle::LK_Proto ||
Style.Language == FormatStyle::LK_TextProto) {
clang-format: Fix space in direct destructor calls. Before: void F(int& i) { i. ~int(); } After: void F(int& i) { i.~int(); } Also, some cleanups. llvm-svn: 220269
2014-10-21 15:51:54 +08:00
if (Right.is(tok::period) &&
clang-format: Use identifier table for keywords in other languages. Slightly easier to write, more efficient and prevents bugs by misspelling them. No functional changes intended. llvm-svn: 221259
2014-11-04 20:41:02 +08:00
Left.isOneOf(Keywords.kw_optional, Keywords.kw_required,
clang-format: [Proto] Support extending message. Before: extend.foo.Bar { } After: extend .foo.Bar { } llvm-svn: 253667
2015-11-20 22:32:54 +08:00
Keywords.kw_repeated, Keywords.kw_extend))
clang-format: Fix space in direct destructor calls. Before: void F(int& i) { i. ~int(); } After: void F(int& i) { i.~int(); } Also, some cleanups. llvm-svn: 220269
2014-10-21 15:51:54 +08:00
return true;
if (Right.is(tok::l_paren) &&
clang-format: Use identifier table for keywords in other languages. Slightly easier to write, more efficient and prevents bugs by misspelling them. No functional changes intended. llvm-svn: 221259
2014-11-04 20:41:02 +08:00
Left.isOneOf(Keywords.kw_returns, Keywords.kw_option))
clang-format: Fix space in direct destructor calls. Before: void F(int& i) { i. ~int(); } After: void F(int& i) { i.~int(); } Also, some cleanups. llvm-svn: 220269
2014-10-21 15:51:54 +08:00
return true;
[clang-format] Add space between a message field key and the opening bracket in proto messages Summary: This patch updates the formatting of message fields of type `a{...}` to `a {...}` for proto messages. Reviewers: djasper Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D35015 llvm-svn: 307261
2017-07-06 21:58:29 +08:00
if (Right.isOneOf(tok::l_brace, tok::less) && Left.is(TT_SelectorName))
return true;
[clang-format] Support text proto extensions Summary: This adds support for text proto extensions, like: ``` msg { [type.type/ext] { key: value } } ``` Reviewers: djasper Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D43180 llvm-svn: 324995
2018-02-13 18:20:39 +08:00
// Slashes occur in text protocol extension syntax: [type/type] { ... }.
if (Left.is(tok::slash) || Right.is(tok::slash))
return false;
if (Left.MatchingParen && Left.MatchingParen->is(TT_ProtoExtensionLSquare) &&
Right.isOneOf(tok::l_brace, tok::less))
return !Style.Cpp11BracedListStyle;
[clang-format] Recognize percents as format specifiers in protos Summary: Frequently, a percent in protos denotes a formatting specifier for string replacement. Thus it is desirable to keep the percent together with what follows after it. Reviewers: djasper Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D43294 llvm-svn: 325159
2018-02-15 03:47:58 +08:00
// A percent is probably part of a formatting specification, such as %lld.
if (Left.is(tok::percent))
return false;
[clang-format] Preserve spaces before a percent in (text) protos This makes sure that we do not change the meaning of pieces of text with format specifiers. llvm-svn: 329263
2018-04-05 17:33:03 +08:00
// Preserve the existence of a space before a percent for cases like 0x%04x
// and "%d %d"
if (Left.is(tok::numeric_constant) && Right.is(tok::percent))
return Right.WhitespaceRange.getEnd() != Right.WhitespaceRange.getBegin();
clang-format: Fix space in direct destructor calls. Before: void F(int& i) { i. ~int(); } After: void F(int& i) { i.~int(); } Also, some cleanups. llvm-svn: 220269
2014-10-21 15:51:54 +08:00
} else if (Style.Language == FormatStyle::LK_JavaScript) {
clang-format: [JS] Fix incorrect spacing around contextual keywords. Before: x.of (); After: x.of(); llvm-svn: 263710
2016-03-17 20:17:59 +08:00
if (Left.is(TT_JsFatArrow))
return true;
clang-format: [JS] for await, and fix a crash with for loops. Summary: The syntax is actually `for await (const x of y)` (d'oh). This also fixes a crash for `for` tokens not followed by additional tokens. Reviewers: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D33329 llvm-svn: 303382
2017-05-19 05:19:29 +08:00
// for await ( ...
clang-format clang-format. llvm-svn: 313744
2017-09-20 17:51:03 +08:00
if (Right.is(tok::l_paren) && Left.is(Keywords.kw_await) && Left.Previous &&
Left.Previous->is(tok::kw_for))
clang-format: [JS] for async loops. Summary: JavaScript supports asynchronous loop iteration in async functions: for async (const x of y) ... Reviewers: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D33193 llvm-svn: 303106
2017-05-16 03:33:20 +08:00
return true;
clang-format: [JS] whitespace after async in arrow functions. Summary: Async arrow functions should be marked with a whitespace after the async keyword, before the parameter list: x = async () => foo(); Before: x = async() => foo(); This makes it easier to tell apart an async arrow function from a call to a function called async. Reviewers: bkramer Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30399 llvm-svn: 296330
2017-02-27 19:15:53 +08:00
if (Left.is(Keywords.kw_async) && Right.is(tok::l_paren) &&
Right.MatchingParen) {
const FormatToken *Next = Right.MatchingParen->getNextNonComment();
// An async arrow function, for example: `x = async () => foo();`,
// as opposed to calling a function called async: `x = async();`
if (Next && Next->is(TT_JsFatArrow))
return true;
}
clang-format: [JS] nested and tagged template strings. JavaScript template strings can be nested arbitrarily: foo = `text ${es.map(e => { return `<${e}>`; })} text`; This change lexes nested template strings using a stack of lexer states to correctly switch back to template string lexing on closing braces. Also, reuse the same stack for the token-stashed logic. Reviewers: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D22431 llvm-svn: 279727
2016-08-25 18:13:21 +08:00
if ((Left.is(TT_TemplateString) && Left.TokenText.endswith("${")) ||
(Right.is(TT_TemplateString) && Right.TokenText.startswith("}")))
return false;
clang-format: [JS] space between pseudo keywords and template literals. Summary: Before: yield`foo`; After: yield `foo`; This reinstates commit 71d3b5cd91 / r307023 and fixes the logic by introducing an explicit table of JavaScript pseudo keywords. Reviewers: djasper Subscribers: klimek Differential Revision: https://reviews.llvm.org/D34953 llvm-svn: 307087
2017-07-04 23:30:21 +08:00
// In tagged template literals ("html`bar baz`"), there is no space between
// the tag identifier and the template string. getIdentifierInfo makes sure
// that the identifier is not a pseudo keyword like `yield`, either.
if (Left.is(tok::identifier) && Keywords.IsJavaScriptIdentifier(Left) &&
Right.is(TT_TemplateString))
clang-format: [JS] nested and tagged template strings. JavaScript template strings can be nested arbitrarily: foo = `text ${es.map(e => { return `<${e}>`; })} text`; This change lexes nested template strings using a stack of lexer states to correctly switch back to template string lexing on closing braces. Also, reuse the same stack for the token-stashed logic. Reviewers: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D22431 llvm-svn: 279727
2016-08-25 18:13:21 +08:00
return false;
clang-format: [JS] generator and async functions. For generators, see: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Iterators_and_generators async functions are not quite in the spec yet, but stage 3 and already widely used: http://tc39.github.io/ecmascript-asyncawait/ Reviewers: djasper Subscribers: klimek Differential Revision: http://reviews.llvm.org/D19204 llvm-svn: 267368
2016-04-25 06:05:09 +08:00
if (Right.is(tok::star) &&
Left.isOneOf(Keywords.kw_function, Keywords.kw_yield))
return false;
clang-format: [JS] Fix missing space after 'yield'. Before: class X { delete(val) { return null; } * gen() { yield[1, 2]; } * gen() { yield{a: 1}; } }; After: class X { delete(val) { return null; } * gen() { yield [1, 2]; } * gen() { yield {a: 1}; } }; llvm-svn: 285569
2016-10-31 21:18:25 +08:00
if (Right.isOneOf(tok::l_brace, tok::l_square) &&
clang-format: [JS] handle object types in extends positions. Summary: clang-format would previously drop the whitespace after `extends` in code such as: class Foo extends {} {} Where the first set of curly braces is an inline object literal type. Reviewers: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D36131 llvm-svn: 309695
2017-08-01 23:46:10 +08:00
Left.isOneOf(Keywords.kw_function, Keywords.kw_yield,
Keywords.kw_extends, Keywords.kw_implements))
clang-format: [JS] Fix missing space after 'yield'. Before: class X { delete(val) { return null; } * gen() { yield[1, 2]; } * gen() { yield{a: 1}; } }; After: class X { delete(val) { return null; } * gen() { yield [1, 2]; } * gen() { yield {a: 1}; } }; llvm-svn: 285569
2016-10-31 21:18:25 +08:00
return true;
clang-format: [JS] do not insert whitespace in call positions. Summary: In JavaScript, may keywords can be used in method names and thus call sites: foo.delete(); foo.instanceof(); clang-format would previously insert whitespace after the `instanceof`. This change generically skips inserting whitespace between a keyword and a parenthesis if preceded by a dot, i.e. in a callsite. Reviewers: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D36142 llvm-svn: 310851
2017-08-15 00:08:16 +08:00
if (Right.is(tok::l_paren)) {
// JS methods can use some keywords as names (e.g. `delete()`).
if (Line.MustBeDeclaration && Left.Tok.getIdentifierInfo())
return false;
// Valid JS method names can include keywords, e.g. `foo.delete()` or
// `bar.instanceof()`. Recognize call positions by preceding period.
if (Left.Previous && Left.Previous->is(tok::period) &&
Left.Tok.getIdentifierInfo())
return false;
// Additional unary JavaScript operators that need a space after.
if (Left.isOneOf(tok::kw_throw, Keywords.kw_await, Keywords.kw_typeof,
tok::kw_void))
return true;
}
clang-format: [JS] fix whitespace around "of" operator. Summary: Previously: import {of } from 'x'; of (null); Now: import {of} from 'x'; of(null); Reviewers: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D31698 llvm-svn: 299533
2017-04-05 18:56:07 +08:00
if ((Left.isOneOf(Keywords.kw_let, Keywords.kw_var, Keywords.kw_in,
tok::kw_const) ||
// "of" is only a keyword if it appears after another identifier
clang-format: [JS] handle destructuring `of`. Summary: Previously, clang-format would drop a space character between `of` and then following (non-identifier) token if the preceding token was part of a destructuring assignment (`}` or `]`). Before: for (const [a, b] of[]) {} After: for (const [a, b] of []) {} Reviewers: djasper Subscribers: klimek Differential Revision: https://reviews.llvm.org/D40411 llvm-svn: 318942
2017-11-24 18:48:25 +08:00
// (e.g. as "const x of y" in a for loop), or after a destructuring
// operation (const [x, y] of z, const {a, b} of c).
clang-format: [JS] fix whitespace around "of" operator. Summary: Previously: import {of } from 'x'; of (null); Now: import {of} from 'x'; of(null); Reviewers: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D31698 llvm-svn: 299533
2017-04-05 18:56:07 +08:00
(Left.is(Keywords.kw_of) && Left.Previous &&
clang-format: [JS] fix `of` detection. Summary: `of` is only a keyword when after an identifier, but not when after an actual keyword. Before: return of (a, b, c); After: return of(a, b, c); Reviewers: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D43440 llvm-svn: 325489
2018-02-19 20:32:13 +08:00
(Left.Previous->Tok.is(tok::identifier) ||
clang-format: [JS] handle destructuring `of`. Summary: Previously, clang-format would drop a space character between `of` and then following (non-identifier) token if the preceding token was part of a destructuring assignment (`}` or `]`). Before: for (const [a, b] of[]) {} After: for (const [a, b] of []) {} Reviewers: djasper Subscribers: klimek Differential Revision: https://reviews.llvm.org/D40411 llvm-svn: 318942
2017-11-24 18:48:25 +08:00
Left.Previous->isOneOf(tok::r_square, tok::r_brace)))) &&
clang-format: [JS] Fix incorrect spacing around contextual keywords. Before: x.of (); After: x.of(); llvm-svn: 263710
2016-03-17 20:17:59 +08:00
(!Left.Previous || !Left.Previous->is(tok::period)))
clang-format: Fix space in direct destructor calls. Before: void F(int& i) { i. ~int(); } After: void F(int& i) { i.~int(); } Also, some cleanups. llvm-svn: 220269
2014-10-21 15:51:54 +08:00
return true;
clang-format: [JS] Fix incorrect space when "as" is used as identifier. Before: aaaaa.as (); After: aaaaa.as(); llvm-svn: 285672
2016-11-01 14:23:10 +08:00
if (Left.isOneOf(tok::kw_for, Keywords.kw_as) && Left.Previous &&
clang-format: [JS] Fix space when for is used as regular identifier. Before: x.for () = 1; After: x.for() = 1; llvm-svn: 285669
2016-11-01 14:22:54 +08:00
Left.Previous->is(tok::period) && Right.is(tok::l_paren))
return false;
clang-format: [JS] supports casts to types starting with punctuation ("{[("). Before: x as{x: number} After: x as {x: number} Reviewers: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D23761 llvm-svn: 279436
2016-08-22 22:23:30 +08:00
if (Left.is(Keywords.kw_as) &&
Right.isOneOf(tok::l_square, tok::l_brace, tok::l_paren))
return true;
clang-format: [JS] Support more ES6 default exports. llvm-svn: 256759
2016-01-05 00:10:36 +08:00
if (Left.is(tok::kw_default) && Left.Previous &&
Left.Previous->is(tok::kw_export))
return true;
clang-format: [JS] Support TypeScript 1.6 user defined type guards. Before: function foo(check: Object): check is{foo: string, bar: string, baz: string, foobar: string} { return 'bar' in check; } After: function foo(check: Object): check is {foo: string, bar: string, baz: string, foobar: string} { return 'bar' in check; } llvm-svn: 256631
2015-12-30 16:00:58 +08:00
if (Left.is(Keywords.kw_is) && Right.is(tok::l_brace))
return true;
clang-format: [JS] support optionality markers in JS types. Patch by Martin Probst. Thank you. llvm-svn: 234753
2015-04-13 23:01:40 +08:00
if (Right.isOneOf(TT_JsTypeColon, TT_JsTypeOptionalQuestion))
clang-format: [JS] Support type annotations. This patch adds support for type annotations that follow TypeScript's, Flow's, and AtScript's syntax style. Patch by Martin Probst, thank you. Review: http://reviews.llvm.org/D7721 llvm-svn: 229700
2015-02-19 01:09:53 +08:00
return false;
clang-format: [JS] no space in union and intersection types. The operators | and & in types, as opposed to the bitwise operators, should not have whitespace around them (e.g. `Foo<Bar|Baz>`). Patch by Martin Probst. Thank you. llvm-svn: 263961
2016-03-22 01:57:31 +08:00
if (Left.is(TT_JsTypeOperator) || Right.is(TT_JsTypeOperator))
return false;
clang-format: [js] Support ES6 module imports. Patch by Martin Probst. llvm-svn: 229863
2015-02-20 00:07:32 +08:00
if ((Left.is(tok::l_brace) || Right.is(tok::r_brace)) &&
clang-format: [js] Support ES6 module exports. Patch by Martin Probst, thank you! llvm-svn: 229865
2015-02-20 00:14:18 +08:00
Line.First->isOneOf(Keywords.kw_import, tok::kw_export))
clang-format: [js] Support ES6 module imports. Patch by Martin Probst. llvm-svn: 229863
2015-02-20 00:07:32 +08:00
return false;
clang-format: [JS] Support ES6 spread operator. Specifically, don't add a space before it. Before: someFunction(... a); var x = [1, 2, ... a]; After: someFunction(...a); var x = [1, 2, ...a]; llvm-svn: 238183
2015-05-26 15:18:56 +08:00
if (Left.is(tok::ellipsis))
return false;
clang-format: [JS] support cast syntax and type arguments. Casts in TS syntax (foo = <type>bar;) should not be followed by whitespace. Patch by Martin Probst. Thank you. llvm-svn: 232321
2015-03-15 21:59:51 +08:00
if (Left.is(TT_TemplateCloser) &&
clang-format: [JS] Fix templated parameter default values. Parameters can have templated types and default values (= ...), which is another location in which a template closer should be followed by whitespace. Patch by Martin Probst, thank you. llvm-svn: 236382
2015-05-02 15:54:58 +08:00
!Right.isOneOf(tok::equal, tok::l_brace, tok::comma, tok::l_square,
clang-format: [JS] support cast syntax and type arguments. Casts in TS syntax (foo = <type>bar;) should not be followed by whitespace. Patch by Martin Probst. Thank you. llvm-svn: 232321
2015-03-15 21:59:51 +08:00
Keywords.kw_implements, Keywords.kw_extends))
// Type assertions ('<type>expr') are not followed by whitespace. Other
// locations that should have whitespace following are identified by the
// above set of follower tokens.
return false;
clang-format: [JS] allow breaking after non-null assertions. Summary: Previously clang-format would not break after any !. However in TypeScript, ! can be used as a post fix operator for non-nullability: x.foo()!.bar()!; With this change, clang-format will wrap after the ! if it is likely a post-fix non null operator. Reviewers: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D30705 llvm-svn: 297606
2017-03-13 17:14:23 +08:00
if (Right.is(TT_JsNonNullAssertion))
clang-format: [JS] post-fix non-null assertion operator. Summary: Do not insert whitespace preceding the "!" postfix operator. This is an incomplete fix, but should cover common usage. Reviewers: djasper Subscribers: cfe-commits, klimek Differential Revision: http://reviews.llvm.org/D21204 llvm-svn: 272524
2016-06-13 08:49:54 +08:00
return false;
clang-format: [JS] space between ! assert and in. Summary: Before: x = y!in z; After: x = y! in z; Reviewers: djasper Subscribers: klimek Differential Revision: https://reviews.llvm.org/D40433 llvm-svn: 318957
2017-11-25 01:04:40 +08:00
if (Left.is(TT_JsNonNullAssertion) &&
Right.isOneOf(Keywords.kw_as, Keywords.kw_in))
return true; // "x! as string", "x! in y"
clang-format: [Java] Add space between "synchronized" and "(". Before: synchronized(mData) { // ... } After: synchronized (mData) { // ... } This fixes llvm.org/PR21455. llvm-svn: 221110
2014-11-03 06:00:57 +08:00
} else if (Style.Language == FormatStyle::LK_Java) {
clang-format: [Java] Space before array initializers. Before: new int[]{1, 2, 3, 4}; After: new int[] {1, 2, 3, 4}; llvm-svn: 222640
2014-11-24 04:54:37 +08:00
if (Left.is(tok::r_square) && Right.is(tok::l_brace))
return true;
clang-format: Use identifier table for keywords in other languages. Slightly easier to write, more efficient and prevents bugs by misspelling them. No functional changes intended. llvm-svn: 221259
2014-11-04 20:41:02 +08:00
if (Left.is(Keywords.kw_synchronized) && Right.is(tok::l_paren))
clang-format: [Java] Add space between "synchronized" and "(". Before: synchronized(mData) { // ... } After: synchronized (mData) { // ... } This fixes llvm.org/PR21455. llvm-svn: 221110
2014-11-03 06:00:57 +08:00
return Style.SpaceBeforeParens != FormatStyle::SBPO_Never;
clang-format: [Java] Support more Java keywords. Before: public final<X> Foo foo() { } public abstract<X> Foo foo(); After: public final <X> Foo foo() { } public abstract <X> Foo foo(); Patch by Harry Terkelsen. Thank you. llvm-svn: 222527
2014-11-21 20:19:07 +08:00
if ((Left.isOneOf(tok::kw_static, tok::kw_public, tok::kw_private,
tok::kw_protected) ||
clang-format: [Java] Detect `native` keyword. Before: public native<X> Foo foo(); After: public native <X> Foo foo(); llvm-svn: 225839
2015-01-14 06:32:50 +08:00
Left.isOneOf(Keywords.kw_final, Keywords.kw_abstract,
Keywords.kw_native)) &&
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
Right.is(TT_TemplateOpener))
clang-format: [Java] Fix static generic methods. Before: public static<R> ArrayList<R> get() {} After: public static <R> ArrayList<R> get() {} llvm-svn: 221122
2014-11-03 10:35:14 +08:00
return true;
clang-format: Fix space in direct destructor calls. Before: void F(int& i) { i. ~int(); } After: void F(int& i) { i.~int(); } Also, some cleanups. llvm-svn: 220269
2014-10-21 15:51:54 +08:00
}
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Left.is(TT_ImplicitStringLiteral))
clang-format: Fix space in direct destructor calls. Before: void F(int& i) { i. ~int(); } After: void F(int& i) { i.~int(); } Also, some cleanups. llvm-svn: 220269
2014-10-21 15:51:54 +08:00
return Right.WhitespaceRange.getBegin() != Right.WhitespaceRange.getEnd();
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
if (Line.Type == LT_ObjCMethodDecl) {
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Left.is(TT_ObjCMethodSpecifier))
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return true;
[clang-format/ObjC] Use getIdentifierInfo() instead of tok::identifier Summary: Previously, we checked tokens for `tok::identifier` to see if they were identifiers inside an Objective-C selector. However, this missed C++ keywords like `new` and `delete`. To fix this, this diff uses `getIdentifierInfo()` to find identifiers or keywords inside Objective-C selectors. Test Plan: New tests added. Ran tests with: % make -j16 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: djasper, jolesiak Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D46143 llvm-svn: 331067
2018-04-28 02:51:12 +08:00
if (Left.is(tok::r_paren) && canBeObjCSelectorComponent(Right))
[clang-format] Don't insert space between r_paren and 'new' in ObjC decl Summary: Previously, clang-format would insert a space between the closing parenthesis and 'new' in the following valid Objective-C declaration: + (instancetype)new; This was because 'new' is treated as a keyword, not an identifier. TokenAnnotator::spaceRequiredBefore() already handled the case where r_paren came before an identifier, so this diff extends it to handle r_paren before 'new'. Test Plan: New tests added. Ran tests with: % make -j12 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: djasper, jolesiak, stephanemoore Reviewed By: djasper, jolesiak, stephanemoore Subscribers: stephanemoore, klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D44692 llvm-svn: 328174
2018-03-22 11:23:53 +08:00
// Don't space between ')' and <id> or ')' and 'new'. 'new' is not a
// keyword in Objective-C, and '+ (instancetype)new;' is a standard class
// method declaration.
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return false;
}
if (Line.Type == LT_ObjCProperty &&
clang-format: Fix space in direct destructor calls. Before: void F(int& i) { i. ~int(); } After: void F(int& i) { i.~int(); } Also, some cleanups. llvm-svn: 220269
2014-10-21 15:51:54 +08:00
(Right.is(tok::equal) || Left.is(tok::equal)))
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return false;
clang-format: More eagerly wrap trailing return types. Before: template <typename T> auto aaaaaaaaaaaaaaaaaaaaaa(T t) -> decltype(eaaaaaaaaaaaaaaa<T>(t.a) .aaaaaaaa()); After: template <typename T> auto aaaaaaaaaaaaaaaaaaaaaa(T t) -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa()); Also add a test case for a difficult template parsing case I stumbled accross. Needs fixing. llvm-svn: 239149
2015-06-05 21:18:09 +08:00
if (Right.isOneOf(TT_TrailingReturnArrow, TT_LambdaArrow) ||
Left.isOneOf(TT_TrailingReturnArrow, TT_LambdaArrow))
Initial support for formatting trailing return types. This fixes llvm.org/PR15170. For now, the basic formatting rules are (based on the C++11 standard): * Surround the "->" with spaces. * Break before "->". Also fix typo. llvm-svn: 185938
2013-07-09 22:36:48 +08:00
return true;
clang-format: Support definitions/declarations of operator,. Before: bool operator, (); After: bool operator,(); llvm-svn: 257256
2016-01-09 23:56:40 +08:00
if (Right.is(TT_OverloadedOperatorLParen))
return Style.SpaceBeforeParens == FormatStyle::SBPO_Always;
clang-format: Fix space in direct destructor calls. Before: void F(int& i) { i. ~int(); } After: void F(int& i) { i.~int(); } Also, some cleanups. llvm-svn: 220269
2014-10-21 15:51:54 +08:00
if (Left.is(tok::comma))
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return true;
clang-format: Fix space in direct destructor calls. Before: void F(int& i) { i. ~int(); } After: void F(int& i) { i.~int(); } Also, some cleanups. llvm-svn: 220269
2014-10-21 15:51:54 +08:00
if (Right.is(tok::comma))
No spaces around pointers to members. Before: (a ->* f)() After: (a->*f)() llvm-svn: 176252
2013-02-28 21:40:17 +08:00
return false;
[clang-format] Add SpaceBeforeColon option Summary: When disabled, this option allows removing the space before colon, making it act more like the semi-colon. When enabled (default), the current behavior is not affected. This mostly affects C++11 loop, initializer list, inheritance list and container literals: class Foo: Bar {} Foo::Foo(): a(a) {} for (auto i: myList) {} f({a: 1, b: 2, c: 3}); Reviewers: krasimir, djasper Reviewed By: djasper Subscribers: xvallspl, teemperor, karies, cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D32525 llvm-svn: 326426
2018-03-01 18:09:13 +08:00
if (Right.is(TT_ObjCBlockLParen))
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return true;
[clang-format] Add SpaceBeforeColon option Summary: When disabled, this option allows removing the space before colon, making it act more like the semi-colon. When enabled (default), the current behavior is not affected. This mostly affects C++11 loop, initializer list, inheritance list and container literals: class Foo: Bar {} Foo::Foo(): a(a) {} for (auto i: myList) {} f({a: 1, b: 2, c: 3}); Reviewers: krasimir, djasper Reviewed By: djasper Subscribers: xvallspl, teemperor, karies, cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D32525 llvm-svn: 326426
2018-03-01 18:09:13 +08:00
if (Right.is(TT_CtorInitializerColon))
return Style.SpaceBeforeCtorInitializerColon;
if (Right.is(TT_InheritanceColon) && !Style.SpaceBeforeInheritanceColon)
return false;
if (Right.is(TT_RangeBasedForLoopColon) &&
!Style.SpaceBeforeRangeBasedForLoopColon)
return false;
clang-format: [JS] support optional methods. Optional methods use ? tokens like this: interface X { y?(): z; } It seems easiest to detect and disambiguate these from ternary expressions by checking if the code is in a declaration context. Turns out that that didn't quite work properly for interfaces in Java and JS, and for JS file root contexts. Patch by Martin Probst, thank you. llvm-svn: 236488
2015-05-05 16:40:32 +08:00
if (Right.is(tok::colon)) {
if (Line.First->isOneOf(tok::kw_case, tok::kw_default) ||
clang-format: Merge labels and subsequent semicolons. E.g.: default:; This can be used to get around restrictions as to what can follow a label. It fixes llvm.org/PR19648. llvm-svn: 236604
2015-05-06 23:19:47 +08:00
!Right.getNextNonComment() || Right.getNextNonComment()->is(tok::semi))
clang-format: [JS] support optional methods. Optional methods use ? tokens like this: interface X { y?(): z; } It seems easiest to detect and disambiguate these from ternary expressions by checking if the code is in a declaration context. Turns out that that didn't quite work properly for interfaces in Java and JS, and for JS file root contexts. Patch by Martin Probst, thank you. llvm-svn: 236488
2015-05-05 16:40:32 +08:00
return false;
if (Right.is(TT_ObjCMethodExpr))
return false;
if (Left.is(tok::question))
return false;
if (Right.is(TT_InlineASMColon) && Left.is(tok::coloncolon))
return false;
if (Right.is(TT_DictLiteral))
return Style.SpacesInContainerLiterals;
[clang-format] Don't detect C++11 attribute specifiers as ObjC Summary: Previously, clang-format would detect C++11 and C++17 attribute specifiers like the following as Objective-C method invocations: [[noreturn]]; [[clang::fallthrough]]; [[noreturn, deprecated("so sorry")]]; [[using gsl: suppress("type")]]; To fix this, I ported part of the logic from tools/clang/lib/Parse/ParseTentative.cpp into TokenAnnotator.cpp so we can explicitly parse and identify C++11 attribute specifiers. This allows the guessLanguage() and getStyle() APIs to correctly guess files containing the C++11 attribute specifiers as C++, not Objective-C. Test Plan: New tests added. Ran tests with: make -j12 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: krasimir, jolesiak, djasper Reviewed By: djasper Subscribers: aaron.ballman, cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D43902 llvm-svn: 327284
2018-03-12 23:42:38 +08:00
if (Right.is(TT_AttributeColon))
return false;
clang-format: [JS] support optional methods. Optional methods use ? tokens like this: interface X { y?(): z; } It seems easiest to detect and disambiguate these from ternary expressions by checking if the code is in a declaration context. Turns out that that didn't quite work properly for interfaces in Java and JS, and for JS file root contexts. Patch by Martin Probst, thank you. llvm-svn: 236488
2015-05-05 16:40:32 +08:00
return true;
}
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Left.is(TT_UnaryOperator))
return Right.is(TT_BinaryOperator);
clang-format: Add missing space before ObjC selector. Before: [self aaaaa:(1 + 2)bbbbb:3]; After: [self aaaaa:(1 + 2) bbbbb:3]; llvm-svn: 237424
2015-05-15 17:05:31 +08:00
// If the next token is a binary operator or a selector name, we have
// incorrectly classified the parenthesis as a cast. FIXME: Detect correctly.
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Left.is(TT_CastRParen))
clang-format: Add missing space before ObjC selector. Before: [self aaaaa:(1 + 2)bbbbb:3]; After: [self aaaaa:(1 + 2) bbbbb:3]; llvm-svn: 237424
2015-05-15 17:05:31 +08:00
return Style.SpaceAfterCStyleCast ||
Right.isOneOf(TT_BinaryOperator, TT_SelectorName);
[clang-format] Adds space around angle brackets in text protos Summary: This patch adds spaces around angle brackets in text proto Google style. Previously these were detected as template openers and closers, which happened to have the expected effect. Now we detect them as scope openers and closers similarly to the way braces are handled in this context. Reviewers: djasper Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D42727 llvm-svn: 324337
2018-02-06 19:34:34 +08:00
if (Left.is(tok::greater) && Right.is(tok::greater)) {
if (Style.Language == FormatStyle::LK_TextProto ||
(Style.Language == FormatStyle::LK_Proto && Left.is(TT_DictLiteral)))
return !Style.Cpp11BracedListStyle;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
return Right.is(TT_TemplateCloser) && Left.is(TT_TemplateCloser) &&
clang-format: Option to control spacing in template argument lists. Same as SpacesInParentheses, this option allows adding a space inside the '<' and '>' of a template parameter list. Patch by Christopher Olsen. This fixes llvm.org/PR17301. llvm-svn: 193614
2013-10-29 22:52:02 +08:00
(Style.Standard != FormatStyle::LS_Cpp11 || Style.SpacesInAngles);
[clang-format] Adds space around angle brackets in text protos Summary: This patch adds spaces around angle brackets in text proto Google style. Previously these were detected as template openers and closers, which happened to have the expected effect. Now we detect them as scope openers and closers similarly to the way braces are handled in this context. Reviewers: djasper Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D42727 llvm-svn: 324337
2018-02-06 19:34:34 +08:00
}
clang-format: Fix C99 designated initializers corner cases Summary: This fixes the missing space before the designated initializer when `Cpp11BracedListStyle=false` : const struct A a = { .a = 1, .b = 2 }; ^ Also, wrapping between opening brace and designated array initializers used to have an excessive penalty (like breaking between an expression and the subscript operator), leading to unexpected wrapping: const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {[1] = aaaaaaaaaaaaaaaaaaaaaaaaaaa, [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbb}; instead of: const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = { [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaa, [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbb}; Finally, designated array initializers are not binpacked, just like designated member initializers. Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, krasimir, klimek Differential Revision: https://reviews.llvm.org/D33491 llvm-svn: 305696
2017-06-19 22:41:21 +08:00
if (Right.isOneOf(tok::arrow, tok::arrowstar, tok::periodstar) ||
Left.isOneOf(tok::arrow, tok::period, tok::arrowstar, tok::periodstar) ||
(Right.is(tok::period) && Right.isNot(TT_DesignatedInitializerPeriod)))
No spaces around pointers to members. Before: (a ->* f)() After: (a->*f)() llvm-svn: 176252
2013-02-28 21:40:17 +08:00
return false;
clang-format: Option to removing the space before assignment operators. Patch contributed by Aaron Wishnick. Thank you! llvm-svn: 191375
2013-09-25 23:15:02 +08:00
if (!Style.SpaceBeforeAssignmentOperators &&
clang-format: Fix space in direct destructor calls. Before: void F(int& i) { i. ~int(); } After: void F(int& i) { i.~int(); } Also, some cleanups. llvm-svn: 220269
2014-10-21 15:51:54 +08:00
Right.getPrecedence() == prec::Assignment)
clang-format: Option to removing the space before assignment operators. Patch contributed by Aaron Wishnick. Thank you! llvm-svn: 191375
2013-09-25 23:15:02 +08:00
return false;
clang-format: Don't remove existing spaces between identifier and ::. This can lead to bad behavior with macros that are used to annotate functions (e.g. ALWAYS_INLINE). Before, this: ALWAYS_INLINE ::std::string getName() ... was turned into: ALWAYS_INLINE::std::string getName() ... If it turns out that clang-format is failing to clean up a lot of the existing spaces now, we can add more analyses of the identifier. It should not currently. Cases where clang-format breaks nested name specifiers should be fine as clang-format wraps after the "::". Thus, a line getting longer and then shorter again should lead to the same original code. llvm-svn: 295437
2017-02-17 18:44:07 +08:00
if (Right.is(tok::coloncolon) && Left.is(tok::identifier))
// Generally don't remove existing spaces between an identifier and "::".
// The identifier might actually be a macro name such as ALWAYS_INLINE. If
// this turns out to be too lenient, add analysis of the identifier itself.
return Right.WhitespaceRange.getBegin() != Right.WhitespaceRange.getEnd();
clang-format: Fix space after argument comments. Before: f(/*a=*/a, /*b=*/ ::b); After: f(/*a=*/a, /*b=*/::b); llvm-svn: 268879
2016-05-09 02:14:01 +08:00
if (Right.is(tok::coloncolon) && !Left.isOneOf(tok::l_brace, tok::comment))
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
return (Left.is(TT_TemplateOpener) &&
clang-format: Fix incorrect space after "<". Before: bool a = 2 <::SomeFunction(); After: bool a = 2 < ::SomeFunction(); llvm-svn: 220505
2014-10-24 04:22:22 +08:00
Style.Standard == FormatStyle::LS_Cpp03) ||
clang-format: Don't remove existing spaces between identifier and ::. This can lead to bad behavior with macros that are used to annotate functions (e.g. ALWAYS_INLINE). Before, this: ALWAYS_INLINE ::std::string getName() ... was turned into: ALWAYS_INLINE::std::string getName() ... If it turns out that clang-format is failing to clean up a lot of the existing spaces now, we can add more analyses of the identifier. It should not currently. Cases where clang-format breaks nested name specifiers should be fine as clang-format wraps after the "::". Thus, a line getting longer and then shorter again should lead to the same original code. llvm-svn: 295437
2017-02-17 18:44:07 +08:00
!(Left.isOneOf(tok::l_paren, tok::r_paren, tok::l_square,
clang-format clang-format. llvm-svn: 313744
2017-09-20 17:51:03 +08:00
tok::kw___super, TT_TemplateCloser,
clang-format: Fix SpacesInParentheses with fully qualified names. When SpacesInParentheses is set to true clang-format does not add a space before fully qualified names. For example: do_something(::globalVar ); Fix by Darby Payne. Thank you! llvm-svn: 328200
2018-03-22 22:30:28 +08:00
TT_TemplateOpener)) ||
(Left.is(tok ::l_paren) && Style.SpacesInParentheses);
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if ((Left.is(TT_TemplateOpener)) != (Right.is(TT_TemplateCloser)))
clang-format: [Java] Improve generic support. Before: Iterable< ? > a; Iterable< ? extends SomeObject > a; After: Iterable<?> a; Iterable<? extends SomeObject> a; llvm-svn: 220281
2014-10-21 17:57:09 +08:00
return Style.SpacesInAngles;
[clang-format] Adjust space around &/&& of structured bindings Keep space before or after the &/&& tokens, but not both. For example, auto [x,y] = a; auto &[xr, yr] = a; // LLVM style auto& [xr, yr] = a; // google style Differential Revision:https://reviews.llvm.org/D35743 llvm-svn: 314264
2017-09-27 08:58:45 +08:00
// Space before TT_StructuredBindingLSquare.
if (Right.is(TT_StructuredBindingLSquare))
return !Left.isOneOf(tok::amp, tok::ampamp) ||
Style.PointerAlignment != FormatStyle::PAS_Right;
// Space before & or && following a TT_StructuredBindingLSquare.
if (Right.Next && Right.Next->is(TT_StructuredBindingLSquare) &&
Right.isOneOf(tok::amp, tok::ampamp))
return Style.PointerAlignment != FormatStyle::PAS_Left;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if ((Right.is(TT_BinaryOperator) && !Left.is(tok::l_paren)) ||
clang-format: Don't use incorrect space in macro calls with operators. Before: MACRO(> ); After: MACRO(>); Not overly important, but easy and good for symmetry reasons :-). llvm-svn: 253669
2015-11-20 23:26:50 +08:00
(Left.isOneOf(TT_BinaryOperator, TT_ConditionalExpr) &&
!Right.is(tok::r_paren)))
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return true;
clang-format: Fix space of arrays of pointers to templated types. Before: vector<int>(*foo_)[6]; After: vector<int> (*foo_)[6]; llvm-svn: 230625
2015-02-26 19:30:50 +08:00
if (Left.is(TT_TemplateCloser) && Right.is(tok::l_paren) &&
Right.isNot(TT_FunctionTypeLParen))
[PR19983] SBPO_Always not covering all the cases. Patch by "Roman Kashitsyn" <romankashicin@gmail.com>. Phabricator revision: http://reviews.llvm.org/D4788 llvm-svn: 214904
2014-08-06 01:58:54 +08:00
return Style.SpaceBeforeParens == FormatStyle::SBPO_Always;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Right.is(TT_TemplateOpener) && Left.is(tok::r_paren) &&
Left.MatchingParen && Left.MatchingParen->is(TT_OverloadedOperatorLParen))
clang-format: Fix overloaded operator edge case. Before: template <class F> void Call(F f) { f.template operator() <int>(); } After: template <class F> void Call(F f) { f.template operator()<int>(); } llvm-svn: 220202
2014-10-20 21:56:30 +08:00
return false;
clang-format: Fix space in direct destructor calls. Before: void F(int& i) { i. ~int(); } After: void F(int& i) { i.~int(); } Also, some cleanups. llvm-svn: 220269
2014-10-21 15:51:54 +08:00
if (Right.is(tok::less) && Left.isNot(tok::l_paren) &&
clang-format: NFC. Add a function to test whether an annotated line starts with a given sequence of tokens. Only the one-token version is used yet, but other usages are coming up momentarily. llvm-svn: 239892
2015-06-17 17:43:56 +08:00
Line.startsWith(tok::hash))
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return true;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Right.is(TT_TrailingUnaryOperator))
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return false;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Left.is(TT_RegexLiteral))
clang-format: [JS] Initial support for regex literals. llvm-svn: 208281
2014-05-08 15:01:45 +08:00
return false;
clang-format: Fix space in direct destructor calls. Before: void F(int& i) { i. ~int(); } After: void F(int& i) { i.~int(); } Also, some cleanups. llvm-svn: 220269
2014-10-21 15:51:54 +08:00
return spaceRequiredBetween(Line, Left, Right);
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
}
clang-format: Fix Allman brace breaking of enums. Before: enum Side { LEFT, RIGHT }; After: enum Side { LEFT, RIGHT }; This fixes llvm.org/PR19911. llvm-svn: 210011
2014-06-02 18:17:32 +08:00
// Returns 'true' if 'Tok' is a brace we'd want to break before in Allman style.
static bool isAllmanBrace(const FormatToken &Tok) {
return Tok.is(tok::l_brace) && Tok.BlockKind == BK_Block &&
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
!Tok.isOneOf(TT_ObjCBlockLBrace, TT_DictLiteral);
clang-format: Fix Allman brace breaking of enums. Before: enum Side { LEFT, RIGHT }; After: enum Side { LEFT, RIGHT }; This fixes llvm.org/PR19911. llvm-svn: 210011
2014-06-02 18:17:32 +08:00
}
clang-format: Don't accidentally move tokens into preprocessor directive. This fixes llvm.org/PR17265. Before: Foo::Foo() #ifdef BAR : baz(0) #endif { } After: Foo::Foo() #ifdef BAR : baz(0) #endif { } llvm-svn: 190861
2013-09-17 17:52:48 +08:00
bool TokenAnnotator::mustBreakBefore(const AnnotatedLine &Line,
const FormatToken &Right) {
clang-format: Let a trailing comma in braced lists enforce linebreaks. Before: vector<int> x{1, 2, 3, 4, }; After: vector<int> x{ 1, 2, 3, 4, }; This fixes llvm.org/PR18519. llvm-svn: 204458
2014-03-21 20:38:57 +08:00
const FormatToken &Left = *Right.Previous;
Do not force linebreaks when MaxEmptyLinesToKeep is 0. Previously we would format call( p); as call( p); with MaxEmptyLinesToKeep == 0. Now we format it as: call(p); llvm-svn: 243429
2015-07-28 23:50:24 +08:00
if (Right.NewlinesBefore > 1 && Style.MaxEmptyLinesToKeep > 0)
clang-format: Leave empty lines within UnwrappedLines. These are commonly used to structure things like enums or long braced lists. There doesn't seem to be a good reason to have the behavior in such structures be different from the behavior between statements. llvm-svn: 210183
2014-06-04 20:40:57 +08:00
return true;
clang-format: Preserve trailing-comma logic even with comments. Before: vector<int> SomeVector = {// aaa 1, 2, }; After: vector<int> SomeVector = { // aaa 1, 2, }; llvm-svn: 221699
2014-11-12 03:34:57 +08:00
clang-format: [JS] Don't put top-level typescript enums on a single line. This makes this consistent with non-typescript enums. Also shuffle the language-dependent stuff in mustBreakBefore to a single location. Patch initiated by Martin Probst. llvm-svn: 239894
2015-06-17 17:44:07 +08:00
if (Style.Language == FormatStyle::LK_JavaScript) {
// FIXME: This might apply to other languages and token kinds.
clang-format: [JS] Optionally re-quote string literals. Turns "foo" into 'foo' (or vice versa, depending on configuration). This makes it more convenient to follow the Google JavaScript style guide: https://google.github.io/styleguide/javascriptguide.xml?showone=Strings#Strings This functionality is behind the option "JavaScriptQuotes", which can be: * "leave" (no re-quoting) * "single" (change to single quotes) * "double" (change to double quotes) This also changes single quoted JavaScript string literals to be treated as tok::string_literal, not tok::char_literal, which fixes two unrelated tests. Patch by Martin Probst. Thank you. llvm-svn: 262534
2016-03-03 06:44:03 +08:00
if (Right.is(tok::string_literal) && Left.is(tok::plus) && Left.Previous &&
Left.Previous->is(tok::string_literal))
clang-format: [JS] Don't put top-level typescript enums on a single line. This makes this consistent with non-typescript enums. Also shuffle the language-dependent stuff in mustBreakBefore to a single location. Patch initiated by Martin Probst. llvm-svn: 239894
2015-06-17 17:44:07 +08:00
return true;
clang-format: clang-format (NFC) llvm-svn: 239903
2015-06-17 21:08:06 +08:00
if (Left.is(TT_DictLiteral) && Left.is(tok::l_brace) && Line.Level == 0 &&
Left.Previous && Left.Previous->is(tok::equal) &&
Line.First->isOneOf(tok::identifier, Keywords.kw_import, tok::kw_export,
tok::kw_const) &&
clang-format: [JS] handle let (ES6) Patch by Martin Probst. Thank you! llvm-svn: 248713
2015-09-28 22:28:08 +08:00
// kw_var/kw_let are pseudo-tokens that are tok::identifier, so match
// above.
!Line.First->isOneOf(Keywords.kw_var, Keywords.kw_let))
clang-format: [JS] Don't put top-level typescript enums on a single line. This makes this consistent with non-typescript enums. Also shuffle the language-dependent stuff in mustBreakBefore to a single location. Patch initiated by Martin Probst. llvm-svn: 239894
2015-06-17 17:44:07 +08:00
// Object literals on the top level of a file are treated as "enum-style".
// Each key/value pair is put on a separate line, instead of bin-packing.
return true;
if (Left.is(tok::l_brace) && Line.Level == 0 &&
(Line.startsWith(tok::kw_enum) ||
clang-format: [JS] consistenly format enums. Summary: Previously, const enums would get formatted differently because the modifier was not recognized. Reviewers: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D36144 llvm-svn: 309703
2017-08-02 01:12:15 +08:00
Line.startsWith(tok::kw_const, tok::kw_enum) ||
Line.startsWith(tok::kw_export, tok::kw_enum) ||
Line.startsWith(tok::kw_export, tok::kw_const, tok::kw_enum)))
clang-format: [JS] Don't put top-level typescript enums on a single line. This makes this consistent with non-typescript enums. Also shuffle the language-dependent stuff in mustBreakBefore to a single location. Patch initiated by Martin Probst. llvm-svn: 239894
2015-06-17 17:44:07 +08:00
// JavaScript top-level enum key/value pairs are put on separate lines
// instead of bin-packing.
return true;
if (Right.is(tok::r_brace) && Left.is(tok::l_brace) &&
!Left.Children.empty())
// Support AllowShortFunctionsOnASingleLine for JavaScript.
return Style.AllowShortFunctionsOnASingleLine == FormatStyle::SFS_None ||
clang-format: [JS] Make AllowShortFunctionsOnASingle line value "Empty" work properly. llvm-svn: 253674
2015-11-21 00:44:28 +08:00
Style.AllowShortFunctionsOnASingleLine == FormatStyle::SFS_Empty ||
clang-format: [JS] Don't put top-level typescript enums on a single line. This makes this consistent with non-typescript enums. Also shuffle the language-dependent stuff in mustBreakBefore to a single location. Patch initiated by Martin Probst. llvm-svn: 239894
2015-06-17 17:44:07 +08:00
(Left.NestingLevel == 0 && Line.Level == 0 &&
clang-format: introduce InlineOnly short function style Summary: This is the same as Inline, except it does not imply all empty functions are merged: with this style, empty functions are merged only if they also match the 'inline' criteria (i.e. defined in a class). This is helpful to avoid inlining functions in implementations files. Reviewers: djasper, krasimir Reviewed By: djasper Subscribers: klimek, rengolin, cfe-commits Differential Revision: https://reviews.llvm.org/D34399 llvm-svn: 305912
2017-06-21 21:56:02 +08:00
Style.AllowShortFunctionsOnASingleLine &
FormatStyle::SFS_InlineOnly);
clang-format: [JS] Don't put top-level typescript enums on a single line. This makes this consistent with non-typescript enums. Also shuffle the language-dependent stuff in mustBreakBefore to a single location. Patch initiated by Martin Probst. llvm-svn: 239894
2015-06-17 17:44:07 +08:00
} else if (Style.Language == FormatStyle::LK_Java) {
if (Right.is(tok::plus) && Left.is(tok::string_literal) && Right.Next &&
Right.Next->is(tok::string_literal))
return true;
clang-format: [JS] Fix incorrect line break in template strings. Before: var f = `aaaa ${a ? 'a' : 'b' }`; After: var f = `aaaa ${a ? 'a' : 'b'}`; llvm-svn: 293618
2017-01-31 20:07:35 +08:00
} else if (Style.Language == FormatStyle::LK_Cpp ||
clang-format: [Proto] Also supports implicit string literal concatenation llvm-svn: 293995
2017-02-03 16:29:02 +08:00
Style.Language == FormatStyle::LK_ObjC ||
[clang-format] Break consecutive string literals in text protos Summary: This patch fixes a bug where consecutive string literals in text protos were put on the same line. Reviewers: alexfh Reviewed By: alexfh Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D44204 llvm-svn: 326945
2018-03-08 05:30:38 +08:00
Style.Language == FormatStyle::LK_Proto ||
Style.Language == FormatStyle::LK_TextProto) {
[clang-format] Handle NSString literals by merging tokens. Summary: This fixes a few outstanding bugs: * incorrect breaking of NSString literals containing double-width characters; * inconsistent formatting of ObjC dictionary literals containing NSString literals; * AlwaysBreakBeforeMultilineStrings ignoring implicitly-concatenated NSString literals. Reviewers: djasper Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D31706 llvm-svn: 299927
2017-04-11 17:55:00 +08:00
if (Left.isStringLiteral() && Right.isStringLiteral())
clang-format: [JS] Fix incorrect line break in template strings. Before: var f = `aaaa ${a ? 'a' : 'b' }`; After: var f = `aaaa ${a ? 'a' : 'b'}`; llvm-svn: 293618
2017-01-31 20:07:35 +08:00
return true;
clang-format: [JS] Don't put top-level typescript enums on a single line. This makes this consistent with non-typescript enums. Also shuffle the language-dependent stuff in mustBreakBefore to a single location. Patch initiated by Martin Probst. llvm-svn: 239894
2015-06-17 17:44:07 +08:00
}
JavaScript allows parameter lists to include trailing commas: myFunction(param1, param2,); For symmetry with other parenthesized lists ([...], {...}), clang-format should wrap parenthesized lists one-per-line if they contain a trailing comma: myFunction( param1, param2, ); This is particularly useful in function declarations or calls with many arguments, e.g. commonly in constructors. Differential Revision: https://reviews.llvm.org/D33023 llvm-svn: 303049
2017-05-15 19:15:29 +08:00
// If the last token before a '}', ']', or ')' is a comma or a trailing
// comment, the intention is to insert a line break after it in order to make
[clang-format] Make NoLineBreakFormatter respect MustBreakBefore Summary: This patch makes NoLineBreakFormatter to insert a break before tokens where MustBreakBefore is true. Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D33238 llvm-svn: 303332
2017-05-18 16:07:52 +08:00
// shuffling around entries easier. Import statements, especially in
// JavaScript, can be an exception to this rule.
if (Style.JavaScriptWrapImports || Line.Type != LT_ImportStatement) {
const FormatToken *BeforeClosingBrace = nullptr;
if ((Left.isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) ||
(Style.Language == FormatStyle::LK_JavaScript &&
Left.is(tok::l_paren))) &&
Left.BlockKind != BK_Block && Left.MatchingParen)
BeforeClosingBrace = Left.MatchingParen->Previous;
else if (Right.MatchingParen &&
(Right.MatchingParen->isOneOf(tok::l_brace,
TT_ArrayInitializerLSquare) ||
(Style.Language == FormatStyle::LK_JavaScript &&
Right.MatchingParen->is(tok::l_paren))))
BeforeClosingBrace = &Left;
if (BeforeClosingBrace && (BeforeClosingBrace->is(tok::comma) ||
BeforeClosingBrace->isTrailingComment()))
return true;
}
clang-format: Preserve trailing-comma logic even with comments. Before: vector<int> SomeVector = {// aaa 1, 2, }; After: vector<int> SomeVector = { // aaa 1, 2, }; llvm-svn: 221699
2014-11-12 03:34:57 +08:00
clang-format: Force line break between "endl" and "<<". This makes piped output easier to read in many instances. Before: llvm::errs() << aaaa << std::endl << bbbb << std::endl; After: llvm::errs() << aaaa << std::endl << bbbb << std::endl; Also fix a few instance of "don't use else after return" as per the coding standards. llvm-svn: 225444
2015-01-08 21:56:57 +08:00
if (Right.is(tok::comment))
clang-format: Preserve trailing-comma logic even with comments. Before: vector<int> SomeVector = {// aaa 1, 2, }; After: vector<int> SomeVector = { // aaa 1, 2, }; llvm-svn: 221699
2014-11-12 03:34:57 +08:00
return Left.BlockKind != BK_BracedInit &&
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
Left.isNot(TT_CtorInitializerColon) &&
Correctly handle escaped newlines when the next token starts without a space. We will need this to correctly handle conflict markers inside macro definitions. llvm-svn: 206029
2014-04-11 20:27:47 +08:00
(Right.NewlinesBefore > 0 && Right.HasUnescapedNewline);
clang-format: Support aligning ObjC string literals. Before: NSString s = @"aaaa" @"bbbb"; After: NSString s = @"aaaa" @"bbbb"; llvm-svn: 237000
2015-05-11 23:15:48 +08:00
if (Left.isTrailingComment())
clang-format: clang-format (NFC) llvm-svn: 239903
2015-06-17 21:08:06 +08:00
return true;
clang-format: Force line break between "endl" and "<<". This makes piped output easier to read in many instances. Before: llvm::errs() << aaaa << std::endl << bbbb << std::endl; After: llvm::errs() << aaaa << std::endl << bbbb << std::endl; Also fix a few instance of "don't use else after return" as per the coding standards. llvm-svn: 225444
2015-01-08 21:56:57 +08:00
if (Right.Previous->IsUnterminatedLiteral)
clang-format: Don't accidentally move tokens into preprocessor directive. This fixes llvm.org/PR17265. Before: Foo::Foo() #ifdef BAR : baz(0) #endif { } After: Foo::Foo() #ifdef BAR : baz(0) #endif { } llvm-svn: 190861
2013-09-17 17:52:48 +08:00
return true;
clang-format: Force line break between "endl" and "<<". This makes piped output easier to read in many instances. Before: llvm::errs() << aaaa << std::endl << bbbb << std::endl; After: llvm::errs() << aaaa << std::endl << bbbb << std::endl; Also fix a few instance of "don't use else after return" as per the coding standards. llvm-svn: 225444
2015-01-08 21:56:57 +08:00
if (Right.is(tok::lessless) && Right.Next &&
Right.Previous->is(tok::string_literal) &&
Right.Next->is(tok::string_literal))
clang-format: Don't accidentally move tokens into preprocessor directive. This fixes llvm.org/PR17265. Before: Foo::Foo() #ifdef BAR : baz(0) #endif { } After: Foo::Foo() #ifdef BAR : baz(0) #endif { } llvm-svn: 190861
2013-09-17 17:52:48 +08:00
return true;
clang-format: Force line break between "endl" and "<<". This makes piped output easier to read in many instances. Before: llvm::errs() << aaaa << std::endl << bbbb << std::endl; After: llvm::errs() << aaaa << std::endl << bbbb << std::endl; Also fix a few instance of "don't use else after return" as per the coding standards. llvm-svn: 225444
2015-01-08 21:56:57 +08:00
if (Right.Previous->ClosesTemplateDeclaration &&
Right.Previous->MatchingParen &&
Right.Previous->MatchingParen->NestingLevel == 0 &&
clang-format: Allow optimizer to break template declaration. Summary: Introduce `PenaltyBreakTemplateDeclaration` to control the penalty, and change `AlwaysBreakTemplateDeclarations` to an enum with 3 modes: * `No` for regular, penalty based, wrapping of template declaration * `MultiLine` for always wrapping before multi-line declarations (e.g. same as legacy behavior when `AlwaysBreakTemplateDeclarations=false`) * `Yes` for always wrapping (e.g. same as legacy behavior when `AlwaysBreakTemplateDeclarations=true`) Reviewers: krasimir, djasper, klimek Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D42684 llvm-svn: 332436
2018-05-16 16:25:03 +08:00
Style.AlwaysBreakTemplateDeclarations == FormatStyle::BTDS_Yes)
clang-format: Don't accidentally move tokens into preprocessor directive. This fixes llvm.org/PR17265. Before: Foo::Foo() #ifdef BAR : baz(0) #endif { } After: Foo::Foo() #ifdef BAR : baz(0) #endif { } llvm-svn: 190861
2013-09-17 17:52:48 +08:00
return true;
clang-format: Introduce BreakConstructorInitializers option Summary: This option replaces the BreakConstructorInitializersBeforeComma option with an enum, thus introducing a mode where the colon stays on the same line as constructor declaration: // When it fits on line: Constructor() : initializer1(), initializer2() {} // When it does not fit: Constructor() : initializer1(), initializer2() {} // When ConstructorInitializerAllOnOneLineOrOnePerLine = true: Constructor() : initializer1(), initializer2() {} Reviewers: krasimir, djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D32479 llvm-svn: 303739
2017-05-24 19:36:58 +08:00
if (Right.is(TT_CtorInitializerComma) &&
Style.BreakConstructorInitializers == FormatStyle::BCIS_BeforeComma &&
!Style.ConstructorInitializerAllOnOneLineOrOnePerLine)
return true;
if (Right.is(TT_CtorInitializerColon) &&
Style.BreakConstructorInitializers == FormatStyle::BCIS_BeforeComma &&
clang-format: Force line break between "endl" and "<<". This makes piped output easier to read in many instances. Before: llvm::errs() << aaaa << std::endl << bbbb << std::endl; After: llvm::errs() << aaaa << std::endl << bbbb << std::endl; Also fix a few instance of "don't use else after return" as per the coding standards. llvm-svn: 225444
2015-01-08 21:56:57 +08:00
!Style.ConstructorInitializerAllOnOneLineOrOnePerLine)
clang-format: Don't accidentally move tokens into preprocessor directive. This fixes llvm.org/PR17265. Before: Foo::Foo() #ifdef BAR : baz(0) #endif { } After: Foo::Foo() #ifdef BAR : baz(0) #endif { } llvm-svn: 190861
2013-09-17 17:52:48 +08:00
return true;
[clang-format] Add option to break before inheritance separation operator in class declaration. Differential Revision: https://reviews.llvm.org/D30487 llvm-svn: 297467
2017-03-10 23:10:37 +08:00
// Break only if we have multiple inheritance.
clang-format: Introduce BreakInheritanceList option Summary: This option replaces the BreakBeforeInheritanceComma option with an enum, thus introducing a mode where the colon stays on the same line as constructor declaration: // When it fits on line: class A : public B, public C { ... }; // When it does not fit: class A : public B, public C { ... }; This matches the behavior of the `BreakConstructorInitializers` option, introduced in https://reviews.llvm.org/D32479. Reviewers: djasper, klimek Reviewed By: djasper Subscribers: mzeren-vmw, cfe-commits Differential Revision: https://reviews.llvm.org/D43015 llvm-svn: 334408
2018-06-11 22:41:26 +08:00
if (Style.BreakInheritanceList == FormatStyle::BILS_BeforeComma &&
Right.is(TT_InheritanceComma))
clang-format clang-format. llvm-svn: 313744
2017-09-20 17:51:03 +08:00
return true;
clang-format: Force line break between "endl" and "<<". This makes piped output easier to read in many instances. Before: llvm::errs() << aaaa << std::endl << bbbb << std::endl; After: llvm::errs() << aaaa << std::endl << bbbb << std::endl; Also fix a few instance of "don't use else after return" as per the coding standards. llvm-svn: 225444
2015-01-08 21:56:57 +08:00
if (Right.is(tok::string_literal) && Right.TokenText.startswith("R\""))
clang-format: Narrow down raw string literal line break exception. For multiline raw string literals, we generally want to respect the author's choice of linebreak before the 'R"(' as the rest of the raw string might be aligned to it and we cannot (commonly) modify the content. For single-line raw string literals, this doesn't make any sense and so we should just treat them as regular string literals in this regard. llvm-svn: 328201
2018-03-22 22:43:54 +08:00
// Multiline raw string literals are special wrt. line breaks. The author
// has made a deliberate choice and might have aligned the contents of the
// string literal accordingly. Thus, we try keep existing line breaks.
return Right.IsMultiline && Right.NewlinesBefore > 0;
[clang-format] Support <>-style proto message fields Summary: This patch adds support for <>-style proto message fields inside proto options. Previously these were wrongly treated as binary operators and as such were working only by chance for a limited number of cases. Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D34621 llvm-svn: 306406
2017-06-27 21:43:07 +08:00
if ((Right.Previous->is(tok::l_brace) ||
clang-format clang-format. llvm-svn: 313744
2017-09-20 17:51:03 +08:00
(Right.Previous->is(tok::less) && Right.Previous->Previous &&
Right.Previous->Previous->is(tok::equal))) &&
[clang-format] Support <>-style proto message fields Summary: This patch adds support for <>-style proto message fields inside proto options. Previously these were wrongly treated as binary operators and as such were working only by chance for a limited number of cases. Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D34621 llvm-svn: 306406
2017-06-27 21:43:07 +08:00
Right.NestingLevel == 1 && Style.Language == FormatStyle::LK_Proto) {
// Don't put enums or option definitions onto single lines in protocol
// buffers.
clang-format: Better support and testing for protocol buffers. With this patch, there is dedicated testing for protocol buffers (https://developers.google.com/protocol-buffers/). Also some minor tweaks formatting tweaks. llvm-svn: 199580
2014-01-19 17:04:08 +08:00
return true;
[clang-format] Support <>-style proto message fields Summary: This patch adds support for <>-style proto message fields inside proto options. Previously these were wrongly treated as binary operators and as such were working only by chance for a limited number of cases. Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D34621 llvm-svn: 306406
2017-06-27 21:43:07 +08:00
}
clang-format: Preserve line break before } in __asm { ... }. Some compilers ignore everything after a semicolon in such inline asm blocks and thus, the closing brace must not be moved to the previous line. llvm-svn: 236946
2015-05-10 16:42:04 +08:00
if (Right.is(TT_InlineASMBrace))
return Right.HasUnescapedNewline;
clang-format: Force line break between "endl" and "<<". This makes piped output easier to read in many instances. Before: llvm::errs() << aaaa << std::endl << bbbb << std::endl; After: llvm::errs() << aaaa << std::endl << bbbb << std::endl; Also fix a few instance of "don't use else after return" as per the coding standards. llvm-svn: 225444
2015-01-08 21:56:57 +08:00
if (isAllmanBrace(Left) || isAllmanBrace(Right))
clang-format: Add a new brace style "custom" as well as flags to control the individual braces. The existing choices for brace wrapping are now merely presets for the different flags that get expanded upon calling the reformat function. All presets have been chose to keep the existing formatting, so there shouldn't be any difference in formatting behavior. Also change the dump_format_style.py to properly document the nested structs that are used to keep these flags discoverable among all the configuration flags. llvm-svn: 248802
2015-09-29 22:57:55 +08:00
return (Line.startsWith(tok::kw_enum) && Style.BraceWrapping.AfterEnum) ||
clang-format clang-format. llvm-svn: 313744
2017-09-20 17:51:03 +08:00
(Line.startsWith(tok::kw_typedef, tok::kw_enum) &&
Style.BraceWrapping.AfterEnum) ||
clang-format: Add a new brace style "custom" as well as flags to control the individual braces. The existing choices for brace wrapping are now merely presets for the different flags that get expanded upon calling the reformat function. All presets have been chose to keep the existing formatting, so there shouldn't be any difference in formatting behavior. Also change the dump_format_style.py to properly document the nested structs that are used to keep these flags discoverable among all the configuration flags. llvm-svn: 248802
2015-09-29 22:57:55 +08:00
(Line.startsWith(tok::kw_class) && Style.BraceWrapping.AfterClass) ||
(Line.startsWith(tok::kw_struct) && Style.BraceWrapping.AfterStruct);
clang-format: Force line break between "endl" and "<<". This makes piped output easier to read in many instances. Before: llvm::errs() << aaaa << std::endl << bbbb << std::endl; After: llvm::errs() << aaaa << std::endl << bbbb << std::endl; Also fix a few instance of "don't use else after return" as per the coding standards. llvm-svn: 225444
2015-01-08 21:56:57 +08:00
if (Left.is(TT_ObjCBlockLBrace) && !Style.AllowShortBlocksOnASingleLine)
return true;
clang-format: Recognize lists ending in trailing commas correctly. Previously, this did not look through trailing comments leading to a few formatting oddities. llvm-svn: 205843
2014-04-09 17:53:23 +08:00
clang-format: [js] Support ES6 module imports. Patch by Martin Probst. llvm-svn: 229863
2015-02-20 00:07:32 +08:00
if ((Style.Language == FormatStyle::LK_Java ||
Style.Language == FormatStyle::LK_JavaScript) &&
Left.is(TT_LeadingJavaAnnotation) &&
Right.isNot(TT_LeadingJavaAnnotation) && Right.isNot(tok::l_paren) &&
clang-format/java: Break after annotations on fields in Chromium style. Chromium follows the Android style guide for Java code, and that doesn't make the distinction between fields and non-fields that the Google Java style guide makes: https://source.android.com/source/code-style.html#use-standard-java-annotations https://google.github.io/styleguide/javaguide.html#s4.8.5-annotations llvm-svn: 250422
2015-10-16 00:03:01 +08:00
(Line.Last->is(tok::l_brace) || Style.BreakAfterJavaFieldAnnotations))
clang-format: [js] Support ES6 module imports. Patch by Martin Probst. llvm-svn: 229863
2015-02-20 00:07:32 +08:00
return true;
[clang-format] Support text proto extensions Summary: This adds support for text proto extensions, like: ``` msg { [type.type/ext] { key: value } } ``` Reviewers: djasper Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D43180 llvm-svn: 324995
2018-02-13 18:20:39 +08:00
if (Right.is(TT_ProtoExtensionLSquare))
return true;
[clang-format] text protos: put entries on separate lines if there is a submessage Summary: This patch updates clang-format text protos to put entries of a submessage into separate lines if the submessage contains at least two entries and contains at least one submessage entry. For example, the entries here are kept on separate lines even if putting them on a single line would be under the column limit: ``` message: { entry: 1 submessage: { key: value } } ``` Messages containing a single submessage or several scalar entries can still be put on one line if they fit: ``` message { submessage { key: value } } message { x: 1 y: 2 z: 3 } ``` Reviewers: sammccall Reviewed By: sammccall Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D46757 llvm-svn: 334401
2018-06-11 20:53:25 +08:00
// In text proto instances if a submessage contains at least 2 entries and at
// least one of them is a submessage, like A { ... B { ... } ... },
// put all of the entries of A on separate lines by forcing the selector of
// the submessage B to be put on a newline.
//
// Example: these can stay on one line:
// a { scalar_1: 1 scalar_2: 2 }
// a { b { key: value } }
//
// and these entries need to be on a new line even if putting them all in one
// line is under the column limit:
// a {
// scalar: 1
// b { key: value }
// }
//
// We enforce this by breaking before a submessage field that has previous
// siblings, *and* breaking before a field that follows a submessage field.
//
// Be careful to exclude the case [proto.ext] { ... } since the `]` is
// the TT_SelectorName there, but we don't want to break inside the brackets.
[clang-format] Keep @message together in text protos Summary: In C++ code snippets of the form `@field` are common. This makes clang-format keep them together in text protos, whereas before it would break them. Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D48543 llvm-svn: 335459
2018-06-25 20:43:12 +08:00
//
// Another edge case is @submessage { key: value }, which is a common
// substitution placeholder. In this case we want to keep `@` and `submessage`
// together.
//
[clang-format] text protos: put entries on separate lines if there is a submessage Summary: This patch updates clang-format text protos to put entries of a submessage into separate lines if the submessage contains at least two entries and contains at least one submessage entry. For example, the entries here are kept on separate lines even if putting them on a single line would be under the column limit: ``` message: { entry: 1 submessage: { key: value } } ``` Messages containing a single submessage or several scalar entries can still be put on one line if they fit: ``` message { submessage { key: value } } message { x: 1 y: 2 z: 3 } ``` Reviewers: sammccall Reviewed By: sammccall Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D46757 llvm-svn: 334401
2018-06-11 20:53:25 +08:00
// We ensure elsewhere that extensions are always on their own line.
if ((Style.Language == FormatStyle::LK_Proto ||
Style.Language == FormatStyle::LK_TextProto) &&
Right.is(TT_SelectorName) && !Right.is(tok::r_square) && Right.Next) {
[clang-format] Keep @message together in text protos Summary: In C++ code snippets of the form `@field` are common. This makes clang-format keep them together in text protos, whereas before it would break them. Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D48543 llvm-svn: 335459
2018-06-25 20:43:12 +08:00
// Keep `@submessage` together in:
// @submessage { key: value }
if (Right.Previous && Right.Previous->is(tok::at))
return false;
[clang-format] text protos: put entries on separate lines if there is a submessage Summary: This patch updates clang-format text protos to put entries of a submessage into separate lines if the submessage contains at least two entries and contains at least one submessage entry. For example, the entries here are kept on separate lines even if putting them on a single line would be under the column limit: ``` message: { entry: 1 submessage: { key: value } } ``` Messages containing a single submessage or several scalar entries can still be put on one line if they fit: ``` message { submessage { key: value } } message { x: 1 y: 2 z: 3 } ``` Reviewers: sammccall Reviewed By: sammccall Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D46757 llvm-svn: 334401
2018-06-11 20:53:25 +08:00
// Look for the scope opener after selector in cases like:
// selector { ...
// selector: { ...
[clang-format] Keep @message together in text protos Summary: In C++ code snippets of the form `@field` are common. This makes clang-format keep them together in text protos, whereas before it would break them. Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D48543 llvm-svn: 335459
2018-06-25 20:43:12 +08:00
// selector: @base { ...
FormatToken *LBrace = Right.Next;
if (LBrace && LBrace->is(tok::colon)) {
LBrace = LBrace->Next;
if (LBrace && LBrace->is(tok::at)) {
LBrace = LBrace->Next;
if (LBrace)
LBrace = LBrace->Next;
}
}
[clang-format] text protos: put entries on separate lines if there is a submessage Summary: This patch updates clang-format text protos to put entries of a submessage into separate lines if the submessage contains at least two entries and contains at least one submessage entry. For example, the entries here are kept on separate lines even if putting them on a single line would be under the column limit: ``` message: { entry: 1 submessage: { key: value } } ``` Messages containing a single submessage or several scalar entries can still be put on one line if they fit: ``` message { submessage { key: value } } message { x: 1 y: 2 z: 3 } ``` Reviewers: sammccall Reviewed By: sammccall Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D46757 llvm-svn: 334401
2018-06-11 20:53:25 +08:00
if (LBrace &&
// The scope opener is one of {, [, <:
// selector { ... }
// selector [ ... ]
// selector < ... >
//
// In case of selector { ... }, the l_brace is TT_DictLiteral.
// In case of an empty selector {}, the l_brace is not TT_DictLiteral,
// so we check for immediately following r_brace.
((LBrace->is(tok::l_brace) &&
(LBrace->is(TT_DictLiteral) ||
(LBrace->Next && LBrace->Next->is(tok::r_brace)))) ||
LBrace->is(TT_ArrayInitializerLSquare) || LBrace->is(tok::less))) {
// If Left.ParameterCount is 0, then this submessage entry is not the
// first in its parent submessage, and we want to break before this entry.
// If Left.ParameterCount is greater than 0, then its parent submessage
// might contain 1 or more entries and we want to break before this entry
// if it contains at least 2 entries. We deal with this case later by
// detecting and breaking before the next entry in the parent submessage.
if (Left.ParameterCount == 0)
return true;
// However, if this submessage is the first entry in its parent
// submessage, Left.ParameterCount might be 1 in some cases.
// We deal with this case later by detecting an entry
// following a closing paren of this submessage.
}
clang-format: [JS] strict prop init annotation. Summary: TypeScript uses the `!` token for strict property initialization assertions, as in: class X { strictPropAsserted!: string; } Previously, clang-format would wrap between the `!` and the `:` for overly long lines. This patch fixes that by generally preventing the wrap in that location. Reviewers: krasimir Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D48030 llvm-svn: 334415
2018-06-12 00:20:13 +08:00
[clang-format] text protos: put entries on separate lines if there is a submessage Summary: This patch updates clang-format text protos to put entries of a submessage into separate lines if the submessage contains at least two entries and contains at least one submessage entry. For example, the entries here are kept on separate lines even if putting them on a single line would be under the column limit: ``` message: { entry: 1 submessage: { key: value } } ``` Messages containing a single submessage or several scalar entries can still be put on one line if they fit: ``` message { submessage { key: value } } message { x: 1 y: 2 z: 3 } ``` Reviewers: sammccall Reviewed By: sammccall Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D46757 llvm-svn: 334401
2018-06-11 20:53:25 +08:00
// If this is an entry immediately following a submessage, it will be
// preceded by a closing paren of that submessage, like in:
// left---. .---right
// v v
// sub: { ... } key: value
// If there was a comment between `}` an `key` above, then `key` would be
// put on a new line anyways.
if (Left.isOneOf(tok::r_brace, tok::greater, tok::r_square))
return true;
}
clang-format: Don't accidentally move tokens into preprocessor directive. This fixes llvm.org/PR17265. Before: Foo::Foo() #ifdef BAR : baz(0) #endif { } After: Foo::Foo() #ifdef BAR : baz(0) #endif { } llvm-svn: 190861
2013-09-17 17:52:48 +08:00
return false;
}
Optionally derive formatting information from the input file. With this patch, clang-format can analyze the input file for two properties: 1. Is "int *a" or "int* a" more common. 2. Are non-C++03 constructs used, e.g. A<A<A>>. With Google-style, clang-format will now use the more common style for (1) and format C++03 compatible, unless it finds C++11 constructs in the input. llvm-svn: 174504
2013-02-06 22:22:40 +08:00
bool TokenAnnotator::canBreakBefore(const AnnotatedLine &Line,
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
const FormatToken &Right) {
const FormatToken &Left = *Right.Previous;
clang-format: [Java] Don't break immediately after "throws". Before: public void doSooooooooooooooooooooooooooomething() throws LooooooooooooooooooooooooooooongException {} After: public void doSooooooooooooooooooooooooooomething() throws LooooooooooooooooooooooooooooongException {} llvm-svn: 220041
2014-10-17 21:36:14 +08:00
clang-format: [JS] Hotfix for runtime issue with deeply nested JS code. I have not succeeded in writing a proper test case for this yet and we also need to solve the underlying fundamental problem of trying too many combinations with nested blocks (basically this somewhat works around our Dijkstra algorithm). Preventing this linebreak is good anyways as usually the penalties never make us choose it (that's why I can't create a test) and it also looks ugly. Also cleaned up state comparison code that I discovered while hunting this down. llvm-svn: 239398
2015-06-09 19:39:22 +08:00
// Language-specific stuff.
clang-format: [Java] Don't break immediately after "throws". Before: public void doSooooooooooooooooooooooooooomething() throws LooooooooooooooooooooooooooooongException {} After: public void doSooooooooooooooooooooooooooomething() throws LooooooooooooooooooooooooooooongException {} llvm-svn: 220041
2014-10-17 21:36:14 +08:00
if (Style.Language == FormatStyle::LK_Java) {
clang-format: Use identifier table for keywords in other languages. Slightly easier to write, more efficient and prevents bugs by misspelling them. No functional changes intended. llvm-svn: 221259
2014-11-04 20:41:02 +08:00
if (Left.isOneOf(Keywords.kw_throws, Keywords.kw_extends,
Keywords.kw_implements))
clang-format: [Java] Don't break immediately after "throws". Before: public void doSooooooooooooooooooooooooooomething() throws LooooooooooooooooooooooooooooongException {} After: public void doSooooooooooooooooooooooooooomething() throws LooooooooooooooooooooooooooooongException {} llvm-svn: 220041
2014-10-17 21:36:14 +08:00
return false;
clang-format: Use identifier table for keywords in other languages. Slightly easier to write, more efficient and prevents bugs by misspelling them. No functional changes intended. llvm-svn: 221259
2014-11-04 20:41:02 +08:00
if (Right.isOneOf(Keywords.kw_throws, Keywords.kw_extends,
Keywords.kw_implements))
clang-format: [Java] Fix class declaration line breaks. Before: @SomeAnnotation() abstract class aaaaaaaaa<a> extends bbbbbbbbbbbb<b> implements cccccccccccc { } After: @SomeAnnotation() abstract class aaaaaaaaa<a> extends bbbbbbbbbbbb<b> implements cccccccccccc { } llvm-svn: 221256
2014-11-04 18:53:14 +08:00
return true;
clang-format: [JS] Hotfix for runtime issue with deeply nested JS code. I have not succeeded in writing a proper test case for this yet and we also need to solve the underlying fundamental problem of trying too many combinations with nested blocks (basically this somewhat works around our Dijkstra algorithm). Preventing this linebreak is good anyways as usually the penalties never make us choose it (that's why I can't create a test) and it also looks ugly. Also cleaned up state comparison code that I discovered while hunting this down. llvm-svn: 239398
2015-06-09 19:39:22 +08:00
} else if (Style.Language == FormatStyle::LK_JavaScript) {
clang-format: [JS] ignore comments when wrapping returns. Summary: When code contains a comment between `return` and the value: return /* lengthy comment here */ ( lengthyValueComesHere); Do not wrap before the comment, as that'd break the code through JS' automatic semicolon insertion. Reviewers: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D24257 llvm-svn: 280730
2016-09-07 02:39:30 +08:00
const FormatToken *NonComment = Right.getPreviousNonComment();
clang-format: [JS] do not wrap after interface and type. Summary: `interface` and `type` are pseudo keywords and cause automatic semicolon insertion when followed by a line break: interface // gets parsed as a long variable access to "interface" VeryLongInterfaceName { } With this change, clang-format not longer wraps after `interface` or `type`. Reviewers: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30874 llvm-svn: 297605
2017-03-13 15:10:18 +08:00
if (NonComment &&
clang-format: [JS] do not wrap after async/await. Summary: Otherwise automatic semicolon insertion can trigger, i.e. wrapping produces invalid syntax. Reviewers: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D40642 llvm-svn: 319415
2017-11-30 18:25:17 +08:00
NonComment->isOneOf(
tok::kw_return, Keywords.kw_yield, tok::kw_continue, tok::kw_break,
tok::kw_throw, Keywords.kw_interface, Keywords.kw_type,
tok::kw_static, tok::kw_public, tok::kw_private, tok::kw_protected,
Keywords.kw_readonly, Keywords.kw_abstract, Keywords.kw_get,
Keywords.kw_set, Keywords.kw_async, Keywords.kw_await))
clang-format: [JS] avoid line breaks before unindented r_parens. The change that enabled wrapping at the previous scope's indentation had unintended side-effects in that clang-format would prefer to wrap closing parentheses to the next line if it avoided a wrap on the next line (assuming very narrow lines): fooObject .someCall(barbazbam) .then(bam); Would get formatted as: fooObject.someCall(barbazbam ).then(bam); Because the ')' is now indented at the parent level (fooObject). Normally formatting a builder pattern style call sequence like that is outlawed in clang-format anyway. However for JavaScript this is special cased to support trailing .bind calls. This change disallows this special case when following a closing ')' to avoid the problem. Included are some random comment fixes. Reviewers: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D33399 llvm-svn: 303557
2017-05-22 22:58:26 +08:00
return false; // Otherwise automatic semicolon insertion would trigger.
clang-format: [JS] Prevent ASI before [ and (. Summary: JavaScript automatic semicolon insertion can trigger before [ and (, so avoid breaking before them if the previous token is likely to terminate an expression. Reviewers: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D42570 llvm-svn: 323532
2018-01-26 23:07:49 +08:00
if (Right.NestingLevel == 0 &&
(Left.Tok.getIdentifierInfo() ||
Left.isOneOf(tok::r_square, tok::r_paren)) &&
Right.isOneOf(tok::l_square, tok::l_paren))
return false; // Otherwise automatic semicolon insertion would trigger.
clang-format: [JS] Hotfix for runtime issue with deeply nested JS code. I have not succeeded in writing a proper test case for this yet and we also need to solve the underlying fundamental problem of trying too many combinations with nested blocks (basically this somewhat works around our Dijkstra algorithm). Preventing this linebreak is good anyways as usually the penalties never make us choose it (that's why I can't create a test) and it also looks ugly. Also cleaned up state comparison code that I discovered while hunting this down. llvm-svn: 239398
2015-06-09 19:39:22 +08:00
if (Left.is(TT_JsFatArrow) && Right.is(tok::l_brace))
return false;
clang-format: [JS] Allow line breaks after TypeScript type colons. llvm-svn: 241339
2015-07-03 18:37:23 +08:00
if (Left.is(TT_JsTypeColon))
return true;
clang-format: [JS] strict prop init annotation. Summary: TypeScript uses the `!` token for strict property initialization assertions, as in: class X { strictPropAsserted!: string; } Previously, clang-format would wrap between the `!` and the `:` for overly long lines. This patch fixes that by generally preventing the wrap in that location. Reviewers: krasimir Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D48030 llvm-svn: 334415
2018-06-12 00:20:13 +08:00
// Don't wrap between ":" and "!" of a strict prop init ("field!: type;").
if (Left.is(tok::exclaim) && Right.is(tok::colon))
return false;
clang-format: [JS] do not wrap before any `is`. Summary: `is` type annotations can occur at any nesting level. For example: function x() { return function y(): a is B { ... }; } Breaking before the `is` above breaks TypeScript parsing the code. This change prevents the wrap. Reviewers: krasimir Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D47193 llvm-svn: 332968
2018-05-22 18:39:07 +08:00
if (Right.is(Keywords.kw_is))
clang-format: [JS] Support TypeScript 1.6 user defined type guards. Before: function foo(check: Object): check is{foo: string, bar: string, baz: string, foobar: string} { return 'bar' in check; } After: function foo(check: Object): check is {foo: string, bar: string, baz: string, foobar: string} { return 'bar' in check; } llvm-svn: 256631
2015-12-30 16:00:58 +08:00
return false;
clang-format: [JS] Treat "in" as a proper operator. llvm-svn: 259350
2016-02-01 19:20:47 +08:00
if (Left.is(Keywords.kw_in))
return Style.BreakBeforeBinaryOperators == FormatStyle::BOS_None;
if (Right.is(Keywords.kw_in))
return Style.BreakBeforeBinaryOperators != FormatStyle::BOS_None;
clang-format: [JS] Do not break before 'as'. Summary: 'as' is a pseudo operator, so automatic semicolon insertion kicks in and the code fails to part. Reviewers: djasper Subscribers: klimek Differential Revision: http://reviews.llvm.org/D21576 llvm-svn: 273422
2016-06-22 22:35:14 +08:00
if (Right.is(Keywords.kw_as))
return false; // must not break before as in 'x as type' casts
clang-format: [JS/TS] Properly understand cast expressions. Many things were wrong: - We didn't always allow wrapping after "as", which can be necessary. - We used to Undestand the identifier after "as" as a start of a name. - We didn't properly parse the structure of the expression with "as" having the precedence of relational operators llvm-svn: 296659
2017-03-02 03:26:12 +08:00
if (Left.is(Keywords.kw_as))
return true;
clang-format: [JS] allow breaking after non-null assertions. Summary: Previously clang-format would not break after any !. However in TypeScript, ! can be used as a post fix operator for non-nullability: x.foo()!.bar()!; With this change, clang-format will wrap after the ! if it is likely a post-fix non null operator. Reviewers: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D30705 llvm-svn: 297606
2017-03-13 17:14:23 +08:00
if (Left.is(TT_JsNonNullAssertion))
return true;
clang-format: [JS] do not break after declare namespace. See TypeScript grammar for tokens following 'declare': https://github.com/Microsoft/TypeScript/blob/master/doc/spec.md#A.10 llvm-svn: 286467
2016-11-11 00:20:58 +08:00
if (Left.is(Keywords.kw_declare) &&
Right.isOneOf(Keywords.kw_module, tok::kw_namespace,
Keywords.kw_function, tok::kw_class, tok::kw_enum,
Keywords.kw_interface, Keywords.kw_type, Keywords.kw_var,
Keywords.kw_let, tok::kw_const))
// See grammar for 'declare' statements at:
// https://github.com/Microsoft/TypeScript/blob/master/doc/spec.md#A.10
return false;
if (Left.isOneOf(Keywords.kw_module, tok::kw_namespace) &&
clang-format: [JS] Improve line-wrapping behavior of template strings. Specifically, similar to other blocks, clang-format now wraps both after "${" and before the corresponding "}", if the contained expression spans multiple lines. llvm-svn: 295663
2017-02-20 22:51:16 +08:00
Right.isOneOf(tok::identifier, tok::string_literal))
clang-format: [JS] do not break after declare namespace. See TypeScript grammar for tokens following 'declare': https://github.com/Microsoft/TypeScript/blob/master/doc/spec.md#A.10 llvm-svn: 286467
2016-11-11 00:20:58 +08:00
return false; // must not break in "module foo { ...}"
clang-format: [JS] Improve line-wrapping behavior of template strings. Specifically, similar to other blocks, clang-format now wraps both after "${" and before the corresponding "}", if the contained expression spans multiple lines. llvm-svn: 295663
2017-02-20 22:51:16 +08:00
if (Right.is(TT_TemplateString) && Right.closesScope())
return false;
if (Left.is(TT_TemplateString) && Left.opensScope())
return true;
clang-format: [Java] Don't break immediately after "throws". Before: public void doSooooooooooooooooooooooooooomething() throws LooooooooooooooooooooooooooooongException {} After: public void doSooooooooooooooooooooooooooomething() throws LooooooooooooooooooooooooooooongException {} llvm-svn: 220041
2014-10-17 21:36:14 +08:00
}
clang-format: Fix bug in ObjC method declaration formatting. Also disallow breaking between "@" and "{" or "[". Before: - (NSAttributedString *)attributedStringForSegment:(NSUInteger)segment index:(NSUInteger)index attributes:(NSDictionary *)attributes nonDigitAttributes:(NSDictionary *) nonDigitAttributes; [mailComposeViewController setToRecipients:@ [ NSBundle.mainBundle.infoDictionary[@"ABBFeedbackEmail"] ]]; After: - (NSAttributedString *)attributedStringForSegment:(NSUInteger)segment index:(NSUInteger)index attributes:(NSDictionary *)attributes nonDigitAttributes: (NSDictionary *)nonDigitAttributes; [mailComposeViewController setToRecipients: @[ NSBundle.mainBundle.infoDictionary[@"ABBFeedbackEmail"] ]]; This fixes llvm.org/PR18030. llvm-svn: 195550
2013-11-23 22:27:27 +08:00
if (Left.is(tok::at))
return false;
clang-format: Don't wrap after @interface. This fixes llvm.org/PR19450. Before: @interface BookmarkHomeHandsetViewController ()<BookmarkAllCollectionViewDelegate, BookmarkFolderCollectionViewDelegate, BookmarkMenuViewControllerDelegate, BookmarkSearchViewControllerDelegate> { } After: @interface aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ()< aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> { } llvm-svn: 207400
2014-04-28 15:34:48 +08:00
if (Left.Tok.getObjCKeywordID() == tok::objc_interface)
return false;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Left.isOneOf(TT_JavaAnnotation, TT_LeadingJavaAnnotation))
clang-format: [Java] Don't line-wrap before annotations' l_parens. Before: @SomeAnnotation (aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa) int i; After: @SomeAnnotation( aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa) int i; llvm-svn: 225963
2015-01-14 17:51:32 +08:00
return !Right.is(tok::l_paren);
clang-format: When putting */& next to types, also wrap before them. Before: LoooooooooooongType * loooooooooooongVariable; After: LoooooooooooongType *loooooooooooongVariable; llvm-svn: 232044
2015-03-12 23:04:53 +08:00
if (Right.is(TT_PointerOrReference))
return Line.IsMultiVariableDeclStmt ||
(Style.PointerAlignment == FormatStyle::PAS_Right &&
(!Right.Next || Right.Next->isNot(TT_FunctionDeclarationName)));
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Right.isOneOf(TT_StartOfName, TT_FunctionDeclarationName) ||
Right.is(tok::kw_operator))
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return true;
clang-format: Fix another bug in wrapping around "*". Before: void aaaaa( aaaaaaaaaaaa* aaaaaaaaaaaaaa) {} // even violation the column limit After: void aaaaa(aaaaaaaaaaaa* aaaaaaaaaaaaaa) {} llvm-svn: 232717
2015-03-19 17:40:16 +08:00
if (Left.is(TT_PointerOrReference))
return false;
clang-format: Make breaking before ternary operators configurable. llvm-svn: 194229
2013-11-08 08:57:11 +08:00
if (Right.isTrailingComment())
// We rely on MustBreakBefore being set correctly here as we should not
// change the "binding" behavior of a comment.
clang-format: Add special case for leading comments in braced lists. A comment following the "{" of a braced list seems to almost always refer to the first element of the list and thus should be aligned to it. Before (with Cpp11 braced list style): SomeFunction({ // Comment 1 "first entry", // Comment 2 "second entry"}); After: SomeFunction({// Comment 1 "first entry", // Comment 2 "second entry"}); llvm-svn: 197725
2013-12-20 05:41:37 +08:00
// The first comment in a braced lists is always interpreted as belonging to
// the first list element. Otherwise, it should be placed outside of the
// list.
clang-format: Introduce BreakConstructorInitializers option Summary: This option replaces the BreakConstructorInitializersBeforeComma option with an enum, thus introducing a mode where the colon stays on the same line as constructor declaration: // When it fits on line: Constructor() : initializer1(), initializer2() {} // When it does not fit: Constructor() : initializer1(), initializer2() {} // When ConstructorInitializerAllOnOneLineOrOnePerLine = true: Constructor() : initializer1(), initializer2() {} Reviewers: krasimir, djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D32479 llvm-svn: 303739
2017-05-24 19:36:58 +08:00
return Left.BlockKind == BK_BracedInit ||
(Left.is(TT_CtorInitializerColon) &&
clang-format clang-format. llvm-svn: 313744
2017-09-20 17:51:03 +08:00
Style.BreakConstructorInitializers == FormatStyle::BCIS_AfterColon);
clang-format: Make breaking before ternary operators configurable. llvm-svn: 194229
2013-11-08 08:57:11 +08:00
if (Left.is(tok::question) && Right.is(tok::colon))
return false;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Right.is(TT_ConditionalExpr) || Right.is(tok::question))
clang-format: Make breaking before ternary operators configurable. llvm-svn: 194229
2013-11-08 08:57:11 +08:00
return Style.BreakBeforeTernaryOperators;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Left.is(TT_ConditionalExpr) || Left.is(tok::question))
clang-format: Make breaking before ternary operators configurable. llvm-svn: 194229
2013-11-08 08:57:11 +08:00
return !Style.BreakBeforeTernaryOperators;
clang-format: Introduce BreakInheritanceList option Summary: This option replaces the BreakBeforeInheritanceComma option with an enum, thus introducing a mode where the colon stays on the same line as constructor declaration: // When it fits on line: class A : public B, public C { ... }; // When it does not fit: class A : public B, public C { ... }; This matches the behavior of the `BreakConstructorInitializers` option, introduced in https://reviews.llvm.org/D32479. Reviewers: djasper, klimek Reviewed By: djasper Subscribers: mzeren-vmw, cfe-commits Differential Revision: https://reviews.llvm.org/D43015 llvm-svn: 334408
2018-06-11 22:41:26 +08:00
if (Left.is(TT_InheritanceColon))
return Style.BreakInheritanceList == FormatStyle::BILS_AfterColon;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Right.is(TT_InheritanceColon))
clang-format: Introduce BreakInheritanceList option Summary: This option replaces the BreakBeforeInheritanceComma option with an enum, thus introducing a mode where the colon stays on the same line as constructor declaration: // When it fits on line: class A : public B, public C { ... }; // When it does not fit: class A : public B, public C { ... }; This matches the behavior of the `BreakConstructorInitializers` option, introduced in https://reviews.llvm.org/D32479. Reviewers: djasper, klimek Reviewed By: djasper Subscribers: mzeren-vmw, cfe-commits Differential Revision: https://reviews.llvm.org/D43015 llvm-svn: 334408
2018-06-11 22:41:26 +08:00
return Style.BreakInheritanceList != FormatStyle::BILS_AfterColon;
clang-format: Support ObjC selectors with unnamed parameters. This fixes llvm.org/PR28063. llvm-svn: 286715
2016-11-12 15:38:22 +08:00
if (Right.is(TT_ObjCMethodExpr) && !Right.is(tok::r_square) &&
Left.isNot(TT_SelectorName))
return true;
[clang-format] Do not break before long string literals in protos Summary: This patch is a follow-up to r323319 (which disables string literal breaking for text protos) and it disables breaking before long string literals. For example this: ``` keyyyyy: "long string literal" ``` used to get broken into: ``` keyyyyy: "long string literal" ``` While at it, I also enabled it for LK_Proto and fixed a bug in the mustBreak code. Reviewers: djasper, sammccall Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D42957 llvm-svn: 324591
2018-02-08 18:47:12 +08:00
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Right.is(tok::colon) &&
!Right.isOneOf(TT_CtorInitializerColon, TT_InlineASMColon))
clang-format: Don't break before a case's colon. Before (with just the right line length: switch (a) { case some_namespace::some_constant : return; } After: switch (a) { case some_namespace:: some_constant: return; } llvm-svn: 209725
2014-05-28 18:09:11 +08:00
return false;
[clang-format] Do not break before long string literals in protos Summary: This patch is a follow-up to r323319 (which disables string literal breaking for text protos) and it disables breaking before long string literals. For example this: ``` keyyyyy: "long string literal" ``` used to get broken into: ``` keyyyyy: "long string literal" ``` While at it, I also enabled it for LK_Proto and fixed a bug in the mustBreak code. Reviewers: djasper, sammccall Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D42957 llvm-svn: 324591
2018-02-08 18:47:12 +08:00
if (Left.is(tok::colon) && Left.isOneOf(TT_DictLiteral, TT_ObjCMethodExpr)) {
[clang-format] Discourage breaks in submessage entries, hard rule Summary: Currently clang-format allows this for text protos: ``` submessage: { key: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' } ``` when it is under the column limit and when putting it all on one line exceeds the column limit. This is not a very intuitive formatting, so I'd prefer having ``` submessage: { key: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' } ``` instead, even if it takes one line more. This patch prevents clang-format from inserting a break between `: {` and similar cases. Reviewers: djasper, sammccall Reviewed By: sammccall Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D48063 llvm-svn: 334517
2018-06-13 01:26:31 +08:00
if (Style.Language == FormatStyle::LK_Proto ||
Style.Language == FormatStyle::LK_TextProto) {
if (!Style.AlwaysBreakBeforeMultilineStrings && Right.isStringLiteral())
return false;
// Prevent cases like:
//
// submessage:
// { key: valueeeeeeeeeeee }
//
// when the snippet does not fit into one line.
// Prefer:
//
// submessage: {
// key: valueeeeeeeeeeee
// }
//
// instead, even if it is longer by one line.
//
// Note that this allows allows the "{" to go over the column limit
// when the column limit is just between ":" and "{", but that does
// not happen too often and alternative formattings in this case are
// not much better.
//
// The code covers the cases:
//
// submessage: { ... }
// submessage: < ... >
// repeated: [ ... ]
if (((Right.is(tok::l_brace) || Right.is(tok::less)) &&
Right.is(TT_DictLiteral)) ||
Right.is(TT_ArrayInitializerLSquare))
return false;
}
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return true;
[clang-format] Do not break before long string literals in protos Summary: This patch is a follow-up to r323319 (which disables string literal breaking for text protos) and it disables breaking before long string literals. For example this: ``` keyyyyy: "long string literal" ``` used to get broken into: ``` keyyyyy: "long string literal" ``` While at it, I also enabled it for LK_Proto and fixed a bug in the mustBreak code. Reviewers: djasper, sammccall Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D42957 llvm-svn: 324591
2018-02-08 18:47:12 +08:00
}
[clang-format] Disallow breaks before ']' in text proto extensions Summary: This disallows patterns like `[ext.name\n]` in text protos. Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D44569 llvm-svn: 327716
2018-03-16 23:23:22 +08:00
if (Right.is(tok::r_square) && Right.MatchingParen &&
Right.MatchingParen->is(TT_ProtoExtensionLSquare))
return false;
clang-format: [ObjC] Further improve wrapping of methods calls without inputs. Before: [aaaaaaaaaaaaaaaaaaaaaaa .aaaaaaaa[aaaaaaaaaaaaaaaaaaaaa] aaaaaaaaaaaaaaaaaaaaaa]; After: [aaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaa[aaaaaaaaaaaaaaaaaaaaa] aaaaaaaaaaaaaaaaaaaaaa]; llvm-svn: 237244
2015-05-13 18:23:03 +08:00
if (Right.is(TT_SelectorName) || (Right.is(tok::identifier) && Right.Next &&
Right.Next->is(TT_ObjCMethodExpr)))
clang-format: Fix regression caused by r237244. Before: [call aaaaaaaa.aaaaaaaa.aaaaaaaa.aaaaaaaa.aaaaaaaa.aaaaaaaa.aaaaaaaa.aaaaaaaa. aaaaaaaa]; After: [call aaaaaaaa.aaaaaaaa.aaaaaaaa.aaaaaaaa.aaaaaaaa.aaaaaaaa.aaaaaaaa.aaaaaaaa .aaaaaaaa]; This merely papers over the fact that we aren't parsing ObjC method calls correctly. Also, the indentation is weird. llvm-svn: 237681
2015-05-19 19:06:33 +08:00
return Left.isNot(tok::period); // FIXME: Properly parse ObjC calls.
clang-format: Improve line breaks in @property. Before: @property(nonatomic, assign, readonly) NSString *looooooooooooooooooooooooooooongName; After: @property(nonatomic, assign, readonly) NSString *looooooooooooooooooooooooooooongName; llvm-svn: 187577
2013-08-01 21:46:58 +08:00
if (Left.is(tok::r_paren) && Line.Type == LT_ObjCProperty)
return true;
clang-format: Always allow break after leading annotations. Before: DEPRECATED("Use NewClass::NewFunction instead.") int OldFunction( const string &parameter) {} Could not be formatted at all, as clang-format would both require and disallow the break before "int". llvm-svn: 245846
2015-08-24 23:10:01 +08:00
if (Left.ClosesTemplateDeclaration || Left.is(TT_FunctionAnnotationRParen))
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return true;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Right.isOneOf(TT_RangeBasedForLoopColon, TT_OverloadedOperatorLParen,
TT_OverloadedOperator))
Align superclasses for multiple inheritence. This fixes llvm.org/PR15179. Before: class ColorChooserMac : public content::ColorChooser, public content::WebContentsObserver { }; After: class ColorChooserMac : public content::ColorChooser, public content::WebContentsObserver { }; llvm-svn: 175147
2013-02-14 16:42:54 +08:00
return false;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Left.is(TT_RangeBasedForLoopColon))
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return true;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Right.is(TT_RangeBasedForLoopColon))
Allow breaking between type and name in for loops. This fixes llvm.org/PR15033. Also: Always break before a parameter, if the previous parameter was split over multiple lines. This was necessary to make the right decisions in for-loops, almost always makes the code more readable and also fixes llvm.org/PR14873. Before: for (llvm::ArrayRef<NamedDecl *>::iterator I = FD->getDeclsInPrototypeScope() .begin(), E = FD->getDeclsInPrototypeScope().end(); I != E; ++I) { } foo(bar(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb, ccccccccccccccccccccccccccccc), d, bar(e, f)); After: for (llvm::ArrayRef<NamedDecl *>::iterator I = FD->getDeclsInPrototypeScope().begin(), E = FD->getDeclsInPrototypeScope().end(); I != E; ++I) { } foo(bar(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb, ccccccccccccccccccccccccccccc), d, bar(e, f)); llvm-svn: 175741
2013-02-21 23:00:29 +08:00
return false;
clang-format: Better support for CUDA's triple brackets. Before: aaaaaaaaaaaaaaa< aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa><<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>(); After: aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa> <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>(); llvm-svn: 286041
2016-11-06 01:43:16 +08:00
if (Left.is(TT_TemplateCloser) && Right.is(TT_TemplateOpener))
return true;
clang-format: When putting */& next to types, also wrap before them. Before: LoooooooooooongType * loooooooooooongVariable; After: LoooooooooooongType *loooooooooooongVariable; llvm-svn: 232044
2015-03-12 23:04:53 +08:00
if (Left.isOneOf(TT_TemplateCloser, TT_UnaryOperator) ||
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
Left.is(tok::kw_operator))
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return false;
clang-format: Allow splitting "= default" and "= delete". Otherwise, this can violate the column limit. llvm-svn: 235592
2015-04-23 20:59:09 +08:00
if (Left.is(tok::equal) && !Right.isOneOf(tok::kw_default, tok::kw_delete) &&
clang-format: Be more conservative about specially indenting blocks in C++. This is a bit of a step back of what we did in r222531, as there are some corner cases in C++, where this kind of formatting is really bad. Example: Before: virtual aaaaaaaaaaaaaaaa(std::function<bool()> IsKindWeWant = [&]() { return true; }, aaaaa aaaaaaaaa); After: virtual aaaaaaaaaaaaaaaa(std::function<bool()> IsKindWeWant = [&]() { return true; }, aaaaa aaaaaaaaa); The block formatting logic in JavaScript will probably go some other changes, too, and we'll potentially be able to make the rules more consistent again. For now, this seems to be the best approach for C++. llvm-svn: 245694
2015-08-21 19:44:57 +08:00
Line.Type == LT_VirtualFunctionDecl && Left.NestingLevel == 0)
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
return false;
clang-format: tweak formatting of variable initialization blocks Summary: This patch changes the behavior of PenaltyBreakBeforeFirstCallParameter so that is does not apply after a brace, when Cpp11BracedListStyle is false. This way, variable initialization is wrapped more like an initializer than like a function call, which is more consistent with user expectations for this braced list style. With PenaltyBreakBeforeFirstCallParameter=200, this gives the following code: (with Cpp11BracedListStyle=false) Before : const std::unordered_map<std::string, int> Something::MyHashTable = { { "aaaaaaaaaaaaaaaaaaaaa", 0 }, { "bbbbbbbbbbbbbbbbbbbbb", 1 }, { "ccccccccccccccccccccc", 2 } }; After : const std::unordered_set<std::string> Something::MyUnorderedSet = { { "aaaaaaaaaaaaaaaaaaaaa", 0 }, { "bbbbbbbbbbbbbbbbbbbbb", 1 }, { "ccccccccccccccccccccc", 2 } }; Reviewers: krasimir, djasper, klimek Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D43290 llvm-svn: 332434
2018-05-16 16:03:52 +08:00
if (Left.is(tok::equal) && Right.is(tok::l_brace) &&
!Style.Cpp11BracedListStyle)
return false;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Left.is(tok::l_paren) && Left.is(TT_AttributeParen))
clang-format: Understand __attribute__s preceding parameter lists. Before: ReturnType __attribute__((unused)) function(int i); After: ReturnType __attribute__((unused)) function(int i); This fixes llvm.org/PR18632. llvm-svn: 200337
2014-01-29 04:13:43 +08:00
return false;
if (Left.is(tok::l_paren) && Left.Previous &&
clang-format: Allow breaking after "else if(" as a last resort. This isn't generally nice, but better than violating the column limit. llvm-svn: 230620
2015-02-26 17:49:08 +08:00
(Left.Previous->isOneOf(TT_BinaryOperator, TT_CastRParen)))
clang-format: Understand __attribute__s preceding parameter lists. Before: ReturnType __attribute__((unused)) function(int i); After: ReturnType __attribute__((unused)) function(int i); This fixes llvm.org/PR18632. llvm-svn: 200337
2014-01-29 04:13:43 +08:00
return false;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Right.is(TT_ImplicitStringLiteral))
clang-format: Fix whitespaces in include directives. Before (clang-format wouldn't change): #include "a.h" #include<a> After: #include "a.h" #include <a> This fixes llvm.org/PR16151. llvm-svn: 193683
2013-10-30 21:54:53 +08:00
return false;
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Right.is(tok::r_paren) || Right.is(TT_TemplateCloser))
clang-format: Enable formatting of nested blocks. Among other things, this enables (better) formatting lambdas and constructs like: MACRO({ long_statement(); long_statement_2(); }, { long_statement(); long_statement_2(); }, { short_statement(); }, ""); This fixes llvm.org/PR15381. llvm-svn: 190038
2013-09-05 17:29:45 +08:00
return false;
clang-format: Don't wrap before the ] of a lambda introducer. Before: return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa([= ](int iiiiiiiiiiii) { return aaaaaaaaaaaaaaaaaaaaaaa != aaaaaaaaaaaaaaaaaaaaaaa; }); After: return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa([=]( int iiiiiiiiiiii) { return aaaaaaaaaaaaaaaaaaaaaaa != aaaaaaaaaaaaaaaaaaaaaaa; }); llvm-svn: 241583
2015-07-07 21:50:50 +08:00
if (Right.is(tok::r_square) && Right.MatchingParen &&
Right.MatchingParen->is(TT_LambdaLSquare))
return false;
clang-format: Enable formatting of nested blocks. Among other things, this enables (better) formatting lambdas and constructs like: MACRO({ long_statement(); long_statement_2(); }, { long_statement(); long_statement_2(); }, { short_statement(); }, ""); This fixes llvm.org/PR15381. llvm-svn: 190038
2013-09-05 17:29:45 +08:00
Improve handling of trailing 'const'. Reduce the preference for breaking before a trailing 'const' according to review comments on r182362. llvm-svn: 182455
2013-05-22 16:28:26 +08:00
// We only break before r_brace if there was a corresponding break before
// the l_brace, which is tracked by BreakBeforeClosingBrace.
clang-format: Enable formatting of nested blocks. Among other things, this enables (better) formatting lambdas and constructs like: MACRO({ long_statement(); long_statement_2(); }, { long_statement(); long_statement_2(); }, { short_statement(); }, ""); This fixes llvm.org/PR15381. llvm-svn: 190038
2013-09-05 17:29:45 +08:00
if (Right.is(tok::r_brace))
return Right.MatchingParen && Right.MatchingParen->BlockKind == BK_Block;
Improve handling of trailing 'const'. Reduce the preference for breaking before a trailing 'const' according to review comments on r182362. llvm-svn: 182455
2013-05-22 16:28:26 +08:00
clang-format: Allow breaking between trailing annotations in more cases. Before: void aaaaaaaaaaaaaa(aaaaaaaa aaa) override AAAAAAAAAAAAAAAAAAAAAAAA( aaaaaaaaaaaaaaa); After: void aaaaaaaaaaaaaa(aaaaaaaa aaa) override AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa); llvm-svn: 205846
2014-04-09 18:29:11 +08:00
// Allow breaking after a trailing annotation, e.g. after a method
// declaration.
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Left.is(TT_TrailingAnnotation))
clang-format: Allow breaking between trailing annotations in more cases. Before: void aaaaaaaaaaaaaa(aaaaaaaa aaa) override AAAAAAAAAAAAAAAAAAAAAAAA( aaaaaaaaaaaaaaa); After: void aaaaaaaaaaaaaa(aaaaaaaa aaa) override AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa); llvm-svn: 205846
2014-04-09 18:29:11 +08:00
return !Right.isOneOf(tok::l_brace, tok::semi, tok::equal, tok::l_paren,
tok::less, tok::coloncolon);
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
[clang-format] Don't detect C++11 attribute specifiers as ObjC Summary: Previously, clang-format would detect C++11 and C++17 attribute specifiers like the following as Objective-C method invocations: [[noreturn]]; [[clang::fallthrough]]; [[noreturn, deprecated("so sorry")]]; [[using gsl: suppress("type")]]; To fix this, I ported part of the logic from tools/clang/lib/Parse/ParseTentative.cpp into TokenAnnotator.cpp so we can explicitly parse and identify C++11 attribute specifiers. This allows the guessLanguage() and getStyle() APIs to correctly guess files containing the C++11 attribute specifiers as C++, not Objective-C. Test Plan: New tests added. Ran tests with: make -j12 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: krasimir, jolesiak, djasper Reviewed By: djasper Subscribers: aaron.ballman, cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D43902 llvm-svn: 327284
2018-03-12 23:42:38 +08:00
if (Right.is(tok::kw___attribute) ||
(Right.is(tok::l_square) && Right.is(TT_AttributeSquare)))
Improve formatting of trailing annotations. Before: bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__(( unused)); After: bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused)); llvm-svn: 177034
2013-03-14 17:50:46 +08:00
return true;
Allow splitting between string literals and identifiers. Also don't break in long include directives as that is not desired. We can now format: #include "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaa" #define LL_FORMAT "ll" printf("aaaaa: %d, bbbbbbbbb: %" LL_FORMAT "d, cccccccc: %" LL_FORMAT "d, ddddddddd: %" LL_FORMAT "d\n"); Before, this led to weird results. llvm-svn: 175959
2013-02-23 15:46:38 +08:00
if (Left.is(tok::identifier) && Right.is(tok::string_literal))
return true;
clang-format: Add two new style options to support WebKit style. New options: * Break before the commas of constructor initializers and align the commas with the colon. * Break before binary operators Additionally, for styles without column limit, don't just accept linebreaks done by the user, but instead remove 'invalid' (according to the current style) linebreaks and add 'required' ones. llvm-svn: 187210
2013-07-27 00:56:36 +08:00
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Right.is(tok::identifier) && Right.Next && Right.Next->is(TT_DictLiteral))
clang-format: Understand proto text format without commas. Also removed spaces before colons as they don't seem to be used frequently. Before: optional int32 b = 2 [(foo_options) = {aaaaaaaaaaaaaaaaaaa : 123 bbbbbbbbbbbbbbbbbbbbbbbb : "baz"}]; After: optional int32 b = 2 [(foo_options) = {aaaaaaaaaaaaaaaaaaa: 123, bbbbbbbbbbbbbbbbbbbbbbbb:"baz"}]; llvm-svn: 206269
2014-04-15 17:54:30 +08:00
return true;
clang-format: Introduce BreakConstructorInitializers option Summary: This option replaces the BreakConstructorInitializersBeforeComma option with an enum, thus introducing a mode where the colon stays on the same line as constructor declaration: // When it fits on line: Constructor() : initializer1(), initializer2() {} // When it does not fit: Constructor() : initializer1(), initializer2() {} // When ConstructorInitializerAllOnOneLineOrOnePerLine = true: Constructor() : initializer1(), initializer2() {} Reviewers: krasimir, djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D32479 llvm-svn: 303739
2017-05-24 19:36:58 +08:00
if (Left.is(TT_CtorInitializerColon))
return Style.BreakConstructorInitializers == FormatStyle::BCIS_AfterColon;
if (Right.is(TT_CtorInitializerColon))
return Style.BreakConstructorInitializers != FormatStyle::BCIS_AfterColon;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Left.is(TT_CtorInitializerComma) &&
clang-format: Introduce BreakConstructorInitializers option Summary: This option replaces the BreakConstructorInitializersBeforeComma option with an enum, thus introducing a mode where the colon stays on the same line as constructor declaration: // When it fits on line: Constructor() : initializer1(), initializer2() {} // When it does not fit: Constructor() : initializer1(), initializer2() {} // When ConstructorInitializerAllOnOneLineOrOnePerLine = true: Constructor() : initializer1(), initializer2() {} Reviewers: krasimir, djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D32479 llvm-svn: 303739
2017-05-24 19:36:58 +08:00
Style.BreakConstructorInitializers == FormatStyle::BCIS_BeforeComma)
clang-format: Add two new style options to support WebKit style. New options: * Break before the commas of constructor initializers and align the commas with the colon. * Break before binary operators Additionally, for styles without column limit, don't just accept linebreaks done by the user, but instead remove 'invalid' (according to the current style) linebreaks and add 'required' ones. llvm-svn: 187210
2013-07-27 00:56:36 +08:00
return false;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Right.is(TT_CtorInitializerComma) &&
clang-format: Introduce BreakConstructorInitializers option Summary: This option replaces the BreakConstructorInitializersBeforeComma option with an enum, thus introducing a mode where the colon stays on the same line as constructor declaration: // When it fits on line: Constructor() : initializer1(), initializer2() {} // When it does not fit: Constructor() : initializer1(), initializer2() {} // When ConstructorInitializerAllOnOneLineOrOnePerLine = true: Constructor() : initializer1(), initializer2() {} Reviewers: krasimir, djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D32479 llvm-svn: 303739
2017-05-24 19:36:58 +08:00
Style.BreakConstructorInitializers == FormatStyle::BCIS_BeforeComma)
clang-format: Improve constructor initializer linewrapping. Specifically make ConstructorInitializerAllOnOneLineOrOnePerLine work nicely with BreakConstructorInitializersBeforeComma. This fixes llvm.org/PR17395. llvm-svn: 192168
2013-10-08 13:11:18 +08:00
return true;
clang-format: Introduce BreakInheritanceList option Summary: This option replaces the BreakBeforeInheritanceComma option with an enum, thus introducing a mode where the colon stays on the same line as constructor declaration: // When it fits on line: class A : public B, public C { ... }; // When it does not fit: class A : public B, public C { ... }; This matches the behavior of the `BreakConstructorInitializers` option, introduced in https://reviews.llvm.org/D32479. Reviewers: djasper, klimek Reviewed By: djasper Subscribers: mzeren-vmw, cfe-commits Differential Revision: https://reviews.llvm.org/D43015 llvm-svn: 334408
2018-06-11 22:41:26 +08:00
if (Left.is(TT_InheritanceComma) &&
Style.BreakInheritanceList == FormatStyle::BILS_BeforeComma)
[clang-format] Add option to break before inheritance separation operator in class declaration. Differential Revision: https://reviews.llvm.org/D30487 llvm-svn: 297467
2017-03-10 23:10:37 +08:00
return false;
clang-format: Introduce BreakInheritanceList option Summary: This option replaces the BreakBeforeInheritanceComma option with an enum, thus introducing a mode where the colon stays on the same line as constructor declaration: // When it fits on line: class A : public B, public C { ... }; // When it does not fit: class A : public B, public C { ... }; This matches the behavior of the `BreakConstructorInitializers` option, introduced in https://reviews.llvm.org/D32479. Reviewers: djasper, klimek Reviewed By: djasper Subscribers: mzeren-vmw, cfe-commits Differential Revision: https://reviews.llvm.org/D43015 llvm-svn: 334408
2018-06-11 22:41:26 +08:00
if (Right.is(TT_InheritanceComma) &&
Style.BreakInheritanceList == FormatStyle::BILS_BeforeComma)
[clang-format] Add option to break before inheritance separation operator in class declaration. Differential Revision: https://reviews.llvm.org/D30487 llvm-svn: 297467
2017-03-10 23:10:37 +08:00
return true;
clang-format: Space and triple angle braces. Committing patch http://reviews.llvm.org/D6800. llvm-svn: 229783
2015-02-19 07:48:37 +08:00
if ((Left.is(tok::greater) && Right.is(tok::greater)) ||
(Left.is(tok::less) && Right.is(tok::less)))
clang-format: Don't split a >>-operator. Before (with column limit 60): aaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa > > aaaaa); After: aaaaaaaaaaaaaaaaaaaaaaaaaaaa( aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa); (Not sure how that could have stayed in that long without being detected..) llvm-svn: 190854
2013-09-17 16:15:46 +08:00
return false;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Right.is(TT_BinaryOperator) &&
clang-format: Add option to break before non-assignment operators. This will allow: int aaaaaaaaaaaaaa = bbbbbbbbbbbbbb + ccccccccccccccc; llvm-svn: 217757
2014-09-15 19:11:00 +08:00
Style.BreakBeforeBinaryOperators != FormatStyle::BOS_None &&
(Style.BreakBeforeBinaryOperators == FormatStyle::BOS_All ||
Right.getPrecedence() != prec::Assignment))
clang-format: Don't break in the middle of ">>". Before: zzzzzzzzzz = bbbbbbbbbbbbbbbbb > > aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa); After: zzzzzzzzzz = bbbbbbbbbbbbbbbbb >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa); This fixes llvm.org/PR19731. llvm-svn: 208672
2014-05-13 16:01:47 +08:00
return true;
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Left.is(TT_ArrayInitializerLSquare))
clang-format: Improve formatting of ObjC array literals. Before: NSArray *arguments = @[ kind == kUserTicket ? @"--user-store" : @"--system-store", @"--print-tickets", @"--productid", @"com.google.Chrome" ]; After: NSArray *arguments = @[ kind == kUserTicket ? @"--user-store" : @"--system-store", @"--print-tickets", @"--productid", @"com.google.Chrome" ]; This fixes llvm.org/PR15231. llvm-svn: 193167
2013-10-22 23:30:28 +08:00
return true;
clang-format: Avoid bad line break. Before: int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa); After: int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa( const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa); llvm-svn: 215442
2014-08-12 21:22:26 +08:00
if (Right.is(tok::kw_typename) && Left.isNot(tok::kw_const))
return true;
clang-format: [Java/JS] Properly support instanceof and its precedence. llvm-svn: 241337
2015-07-03 18:12:53 +08:00
if ((Left.isBinaryOperator() || Left.is(TT_BinaryOperator)) &&
!Left.isOneOf(tok::arrowstar, tok::lessless) &&
clang-format: Add option to break before non-assignment operators. This will allow: int aaaaaaaaaaaaaa = bbbbbbbbbbbbbb + ccccccccccccccc; llvm-svn: 217757
2014-09-15 19:11:00 +08:00
Style.BreakBeforeBinaryOperators != FormatStyle::BOS_All &&
(Style.BreakBeforeBinaryOperators == FormatStyle::BOS_None ||
Left.getPrecedence() == prec::Assignment))
return true;
[clang-format] Don't detect C++11 attribute specifiers as ObjC Summary: Previously, clang-format would detect C++11 and C++17 attribute specifiers like the following as Objective-C method invocations: [[noreturn]]; [[clang::fallthrough]]; [[noreturn, deprecated("so sorry")]]; [[using gsl: suppress("type")]]; To fix this, I ported part of the logic from tools/clang/lib/Parse/ParseTentative.cpp into TokenAnnotator.cpp so we can explicitly parse and identify C++11 attribute specifiers. This allows the guessLanguage() and getStyle() APIs to correctly guess files containing the C++11 attribute specifiers as C++, not Objective-C. Test Plan: New tests added. Ran tests with: make -j12 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: krasimir, jolesiak, djasper Reviewed By: djasper Subscribers: aaron.ballman, cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D43902 llvm-svn: 327284
2018-03-12 23:42:38 +08:00
if ((Left.is(TT_AttributeSquare) && Right.is(tok::l_square)) ||
(Left.is(tok::r_square) && Right.is(TT_AttributeSquare)))
return false;
clang-format: Add option to break before non-assignment operators. This will allow: int aaaaaaaaaaaaaa = bbbbbbbbbbbbbb + ccccccccccccccc; llvm-svn: 217757
2014-09-15 19:11:00 +08:00
return Left.isOneOf(tok::comma, tok::coloncolon, tok::semi, tok::l_brace,
clang-format: Allow splitting the line after /**/-comments. While it might change the meaning of the comment in rare circumstances, it is better than violating the column limit. llvm-svn: 270975
2016-05-27 16:59:34 +08:00
tok::kw_class, tok::kw_struct, tok::comment) ||
clang-format: Force line break in trailing calls after multline exprs. Before: aaaaaaaa(aaaaaaaaaa, bbbbbbbbbb).a(); After: aaaaaaaa(aaaaaaaaaa, bbbbbbbbbb) .a(); llvm-svn: 233304
2015-03-27 02:46:28 +08:00
Right.isMemberAccess() ||
Right.isOneOf(TT_TrailingReturnArrow, TT_LambdaArrow, tok::lessless,
tok::colon, tok::l_square, tok::at) ||
Don't break after a "(" following a binary operator. Additionally, allow breaking after c-style casts, but with a high penalty. Before: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = ( aaaaaaaaaaaaaaaaa *)bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; After: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *) bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; This fixes llvm.org/PR16049. llvm-svn: 185685
2013-07-05 15:58:34 +08:00
(Left.is(tok::r_paren) &&
clang-format: Understand __attribute__s preceding parameter lists. Before: ReturnType __attribute__((unused)) function(int i); After: ReturnType __attribute__((unused)) function(int i); This fixes llvm.org/PR18632. llvm-svn: 200337
2014-01-29 04:13:43 +08:00
Right.isOneOf(tok::identifier, tok::kw_const)) ||
clang-format: Fix bug with conflicting BreakBeforeBinaryOperations and AlignAfterOpenBracket Fix for the formatting options combination of BreakBeforeBinaryOperators: All, AlignAfterOpenBracket: AlwaysBreak not handling long templates correctly. This patch allows a break after an opening left parenthesis, TemplateOpener, or bracket when both options are enabled. Patch by Daphne Pfister, thank you! Fixes llvm.org/PR30304. llvm-svn: 294179
2017-02-06 18:55:49 +08:00
(Left.is(tok::l_paren) && !Right.is(tok::r_paren)) ||
(Left.is(TT_TemplateOpener) && !Right.is(TT_TemplateCloser));
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
}
Revamp indentation behavior for complex binary expressions. The idea is to indent according to operator precedence and pretty much identical to how stuff would be indented with parenthesis. Before: bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa > ccccccccccccccccccccccccccccccccccccccccc; After: bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa > ccccccccccccccccccccccccccccccccccccccccc; llvm-svn: 179049
2013-04-09 04:33:42 +08:00
void TokenAnnotator::printDebugInfo(const AnnotatedLine &Line) {
[clang-format] Fix comment levels between '} else {' and PPDirective. Summary: This fixes a regression exposed by r307795 and rL308725 in which the level of a comment line between '} else {' and a preprocessor directive is incorrectly set as the level of the '} else {' line. For example, this : ``` int f(int i) { if (i) { ++i; } else { // comment #ifdef A --i; #endif } } ``` was formatted as: ``` int f(int i) { if (i) { ++i; } else { // comment #ifdef A --i; #endif } } ``` Reviewers: djasper, klimek Reviewed By: klimek Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D35794 llvm-svn: 308882
2017-07-24 22:51:59 +08:00
llvm::errs() << "AnnotatedTokens(L=" << Line.Level << "):\n";
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
const FormatToken *Tok = Line.First;
Revamp indentation behavior for complex binary expressions. The idea is to indent according to operator precedence and pretty much identical to how stuff would be indented with parenthesis. Before: bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa > ccccccccccccccccccccccccccccccccccccccccc; After: bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa > ccccccccccccccccccccccccccccccccccccccccc; llvm-svn: 179049
2013-04-09 04:33:42 +08:00
while (Tok) {
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
llvm::errs() << " M=" << Tok->MustBreakBefore
clang-format: Print token type name instead of number in -debug output Differential Revision: http://reviews.llvm.org/D11125 llvm-svn: 242039
2015-07-14 00:19:34 +08:00
<< " C=" << Tok->CanBreakBefore
<< " T=" << getTokenTypeName(Tok->Type)
Add experimental flag for adaptive parameter bin-packing. This is not activated for any style, might change or go away completely. For those that want to play around with it, set ExperimentalAutoDetectBinPacking to true. clang-format will then: Look at whether function calls/declarations/definitions are currently formatted with one parameter per line (on a case-by-case basis). If so, clang-format will avoid bin-packing the parameters. If all parameters are on one line (thus that line is "inconclusive"), clang-format will make the choice dependent on whether there are other bin-packed calls/declarations in the same file. The reason for this change is that bin-packing in some situations can be really bad and an author might opt to put one parameter on each line. If the author does that, he might want clang-format not to mess with that. If the author is unhappy with the one-per-line formatting, clang-format can easily be convinced to bin-pack by putting any two parameters on the same line. llvm-svn: 186003
2013-07-10 22:02:49 +08:00
<< " S=" << Tok->SpacesRequiredBefore
clang-format: [JS] Treat dict literals similar to objc method exprs. Before: return { link: function() { f(); // } }; return { a: a, link: function() { f(); // } } After: return { link: function() { f(); // } }; return { a: a, link: function() { f(); // } }; llvm-svn: 210537
2014-06-10 22:44:02 +08:00
<< " B=" << Tok->BlockParameterCount
clang-format clang-format. llvm-svn: 313744
2017-09-20 17:51:03 +08:00
<< " BK=" << Tok->BlockKind << " P=" << Tok->SplitPenalty
<< " Name=" << Tok->Tok.getName() << " L=" << Tok->TotalLength
<< " PPK=" << Tok->PackingKind << " FakeLParens=";
Revamp indentation behavior for complex binary expressions. The idea is to indent according to operator precedence and pretty much identical to how stuff would be indented with parenthesis. Before: bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa > ccccccccccccccccccccccccccccccccccccccccc; After: bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa > ccccccccccccccccccccccccccccccccccccccccc; llvm-svn: 179049
2013-04-09 04:33:42 +08:00
for (unsigned i = 0, e = Tok->FakeLParens.size(); i != e; ++i)
llvm::errs() << Tok->FakeLParens[i] << "/";
clang-format: Keep string-literal-label + value pairs on a line. We have previously done that for <<-operators. This patch also adds this logic for "," and "+". Before: string v = "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa + "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa + "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa; string v = StrCat("aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa, "aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa, "aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa); After: string v = "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa + "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa + "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa; string v = StrCat("aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa, "aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa, "aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa); llvm-svn: 289531
2016-12-13 19:16:42 +08:00
llvm::errs() << " FakeRParens=" << Tok->FakeRParens;
[clang-format/ObjC] Use getIdentifierInfo() instead of tok::identifier Summary: Previously, we checked tokens for `tok::identifier` to see if they were identifiers inside an Objective-C selector. However, this missed C++ keywords like `new` and `delete`. To fix this, this diff uses `getIdentifierInfo()` to find identifiers or keywords inside Objective-C selectors. Test Plan: New tests added. Ran tests with: % make -j16 FormatTests && ./tools/clang/unittests/Format/FormatTests Reviewers: djasper, jolesiak Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D46143 llvm-svn: 331067
2018-04-28 02:51:12 +08:00
llvm::errs() << " II=" << Tok->Tok.getIdentifierInfo();
clang-format: Keep string-literal-label + value pairs on a line. We have previously done that for <<-operators. This patch also adds this logic for "," and "+". Before: string v = "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa + "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa + "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa; string v = StrCat("aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa, "aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa, "aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa); After: string v = "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa + "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa + "aaaaaaaaaaaaaaaa: " + aaaaaaaaaaaaaaaa; string v = StrCat("aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa, "aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa, "aaaaaaaaaaaaaaaa: ", aaaaaaaaaaaaaaaa); llvm-svn: 289531
2016-12-13 19:16:42 +08:00
llvm::errs() << " Text='" << Tok->TokenText << "'\n";
clang-format: Fix bug introduced by r208392. Also run clang-format over clang-format's files. llvm-svn: 208409
2014-05-09 21:11:16 +08:00
if (!Tok->Next)
Support formatting of preprocessor branches. We now correctly format: void SomeFunction(int param1, #ifdef X NoTemplate param2, #else template < #ifdef A MyType<Some> > #else Type1, Type2> #endif param2, #endif param3) { f(); } llvm-svn: 192503
2013-10-12 05:25:45 +08:00
assert(Tok == Line.Last);
The second step in the token refactoring. Gets rid of AnnotatedToken, putting everything into FormatToken. FormatTokens are created once, and only referenced by pointer. This enables multiple future features, like having tokens shared between multiple UnwrappedLines (while there's still work to do to fully enable that). llvm-svn: 182859
2013-05-29 22:47:47 +08:00
Tok = Tok->Next;
Revamp indentation behavior for complex binary expressions. The idea is to indent according to operator precedence and pretty much identical to how stuff would be indented with parenthesis. Before: bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa > ccccccccccccccccccccccccccccccccccccccccc; After: bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa > ccccccccccccccccccccccccccccccccccccccccc; llvm-svn: 179049
2013-04-09 04:33:42 +08:00
}
llvm::errs() << "----\n";
}
Move the token annotator into separate files. No functional changes. Also removed experimental-warning from all of clang-format's files, as it is no longer accurate. llvm-svn: 173830
2013-01-30 05:01:14 +08:00
} // namespace format
} // namespace clang