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

2483 lines
96 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
/// \brief This file implements a token annotator, i.e. creates
/// \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 {
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
/// \brief A parser that gathers additional information about tokens.
///
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
const FormatToken& Previous = *CurrentToken->Previous;
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;
CurrentToken->Type = TT_TemplateCloser;
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) ||
(CurrentToken->isOneOf(tok::colon, tok::question) && InExprContext))
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);
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;
if (CurrentToken->is(tok::caret)) {
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
// (^ can start a block 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
Left->Type = TT_ObjCBlockLParen;
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
} else 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;
} else if (Left->Previous &&
clang-format: Inside decltype(), there is an expression. Before: decltype(a* b) F(); After: decltype(a * b) F(); llvm-svn: 244891
2015-08-13 21:43:51 +08:00
(Left->Previous->isOneOf(tok::kw_static_assert, tok::kw_decltype,
tok::kw_if, tok::kw_while, tok::l_paren,
tok::comma) ||
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
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 &&
Left->Previous->is(Keywords.kw_function)) {
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: 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
bool MightBeFunctionType = CurrentToken->isOneOf(tok::star, tok::amp) &&
!Contexts[Contexts.size() - 2].IsExpression;
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);
[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))
MightBeFunctionType = true;
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)) {
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 (MightBeFunctionType && 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) ||
(CurrentToken->Next->is(tok::l_square) &&
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
Line.MustBeDeclaration)))
Clean up formatting of function types. Before: int (*func)(void*); void f() { int(*func)(void*); } After (consistent space after "int"): int (*func)(void*); void f() { int (*func)(void*); } llvm-svn: 182756
2013-05-28 16:33:00 +08:00
Left->Type = 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: Understand that "auto" is a type. Before: MACRO(auto * a); After: MACRO(auto *a); llvm-svn: 205517
2014-04-03 17:00:49 +08:00
if (CurrentToken->isOneOf(tok::kw_const, tok::kw_auto) ||
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
CurrentToken->isSimpleTypeSpecifier())
Contexts.back().IsExpression = 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->isOneOf(tok::semi, tok::colon))
MightBeObjCForRangeLoop = false;
if (MightBeObjCForRangeLoop && CurrentToken->is(Keywords.kw_in))
CurrentToken->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;
}
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
Fix "the the" in comments/documentation/etc. llvm-svn: 240110
2015-06-19 09:52:53 +08:00
// expression, or it could the start of an Objective-C array literal.
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();
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 =
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
Style.Language == FormatStyle::LK_Cpp &&
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: [JS] Fix spacing in dict literals. Before: someVariable = {'a':[{}]}; After: someVariable = {'a': [{}]}; llvm-svn: 208403
2014-05-09 18:26:08 +08:00
CurrentToken->isNot(tok::l_brace) &&
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() ||
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;
if (Left->is(TT_Unknown)) {
if (StartsObjCMethodExpr) {
Left->Type = TT_ObjCMethodExpr;
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: [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 ||
(Parent &&
clang-format: [JS] Improve empty array literal detection. Previously, the [] in the following example were recognized as an array subscript leading to weird indentation. Before: var aaaa = aaaaa || // wrap []; After: var aaaa = aaaaa || // wrap []; llvm-svn: 256753
2016-01-04 21:11:41 +08:00
Parent->isOneOf(TT_BinaryOperator, tok::at, tok::comma,
tok::l_paren, tok::l_square, tok::question,
clang-format: [JS] Support ES6 exports of array literals. Before: export default[aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb]; export default[]; After: export default [ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb ]; export default []; llvm-svn: 256758
2016-01-04 23:51:56 +08:00
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;
Contexts.back().ColonIsObjCMethodExpr = StartsObjCMethodExpr;
[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: Fix parsing and indenting lambdas. Before: void f() { other(x.begin(), x.end(), // [&](int, int) { return 1; }); } After: void f() { other(x.begin(), x.end(), // [&](int, int) { return 1; }); } llvm-svn: 190039
2013-09-05 18:04:31 +08:00
if (CurrentToken->Next && CurrentToken->Next->is(tok::l_paren) &&
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
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;
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: 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: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Left->is(TT_ArraySubscriptLSquare)) {
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;
Contexts.back().ColonIsObjCMethodExpr = true;
if (Parent && Parent->is(tok::r_paren))
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;
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: [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
if (CurrentToken->isOneOf(tok::colon, tok::l_brace)) {
FormatToken *Previous = CurrentToken->getPreviousNonComment();
clang-format: Fixed typecast getting put on a separate line from the key in Obj-C dictionary literals This fixes: https://llvm.org/PR22647 Patch by Kent Sutherland. Thank you. llvm-svn: 250010
2015-10-12 11:19:07 +08:00
if (((CurrentToken->is(tok::colon) &&
(!Contexts.back().ColonIsDictLiteral ||
Style.Language != FormatStyle::LK_Cpp)) ||
clang-format: Fix regression in formatting of braced initializers. Before: Node n{1, Node{1000}, // 2}; After: Node n{1, Node{1000}, // 2}; llvm-svn: 216540
2014-08-27 19:53:26 +08:00
Style.Language == FormatStyle::LK_Proto) &&
clang-format: [JS] Support quoted object literal keys. Before: var x = { a: a, b: b, 'c': c, }; After: var x = { a: a, b: b, 'c': c, }; llvm-svn: 262291
2016-03-01 12:19:47 +08:00
(Previous->Tok.getIdentifierInfo() ||
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
Previous->is(tok::string_literal)))
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
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
}
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
}
}
return true;
}
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;
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 (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 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] 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 ||
Style.Language == FormatStyle::LK_Proto) {
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;
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: [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
Tok->Previous->Type = TT_SelectorName;
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
if (Tok->Previous->ColumnWidth >
clang-format: Fix corner-case in ObjC method declaration formatting Before: - (void)shortf:(GTMFoo *)theFoo longKeyword:(NSRect)theRect longerKeyword:(float)theInterval error:(NSError **)theError { } After: - (void)shortf:(GTMFoo *)theFoo longKeyword:(NSRect)theRect longerKeyword:(float)theInterval error:(NSError **)theError { } llvm-svn: 256738
2016-01-04 15:29:07 +08:00
Contexts.back().LongestObjCSelectorName)
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
Contexts.back().LongestObjCSelectorName = Tok->Previous->ColumnWidth;
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
if (!Contexts.back().FirstObjCSelectorName)
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
Contexts.back().FirstObjCSelectorName = Tok->Previous;
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)) {
[clang-format] Detect constructor initializers preceded by `noexcept`. Patch by Erik Kessler, thank you. llvm-svn: 262402
2016-03-02 05:41:58 +08:00
if (Tok->Previous->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] 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
} else if (Tok->Previous->is(tok::identifier) && Tok->Next &&
Tok->Next->isOneOf(tok::r_paren, tok::comma)) {
// 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:
[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:
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.
if (Tok->Previous &&
Tok->Previous->is(tok::r_paren) &&
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:
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: 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:
// Lines can start with '}'.
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
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:
Tok->Type = TT_BinaryOperator;
break;
case tok::kw_operator:
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 &&
CurrentToken->Previous->isOneOf(TT_BinaryOperator, 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.
if (Line.MustBeDeclaration &&
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: 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;
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)) {
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
while (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
if (CurrentToken->isNot(tok::comment) || CurrentToken->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
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: [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() {
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;
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;
}
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
while (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: [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
// definitions (code.google.com/p/protobuf) or missing "#" (either way we
// 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] 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))
return LT_ImportStatement;
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
bool KeywordVirtualFound = false;
bool ImportStatement = false;
[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: [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
Tok.Next->Next && (Tok.Next->Next->TokenText == "module" ||
clang-format: [JS] Add goog.setTestOnly to the list of stuff that is import-statement-like and shouldn't be wrapped. llvm-svn: 251643
2015-10-30 03:05:20 +08:00
Tok.Next->Next->TokenText == "provide" ||
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
Tok.Next->Next->TokenText == "require" ||
clang-format: [JS] treat forwardDeclare as an import/export statement. Patch by Martin Probst. Thank you. llvm-svn: 261528
2016-02-22 23:06:53 +08:00
Tok.Next->Next->TokenText == "setTestOnly" ||
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,
TT_RegexLiteral))
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
}
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
/// \brief A struct to hold information valid in a specific context, e.g.
/// 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;
bool CaretFound = false;
bool IsForEachMacro = 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
};
/// \brief Puts a new \c Context onto the stack \c Contexts for the lifetime
/// 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) &&
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;
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;
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
} else if (Current.Previous &&
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
Current.Previous->is(TT_CtorInitializerColon)) {
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
Contexts.back().IsExpression = 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
Contexts.back().InCtorInitializer = true;
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;
// 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;
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)) {
Current.Type =
determineStarAmpUsage(Current, Contexts.back().CanBeExpression &&
Contexts.back().IsExpression,
Contexts.back().InTemplateArgument);
} 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 &&
Line.MustBeDeclaration) {
// 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() &&
(!Current.Previous || Current.Previous->isNot(tok::l_square))) {
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,
tok::period, tok::arrow, tok::coloncolon))
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 (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: 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::at) && Current.Next) {
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 (Current.Next->isStringLiteral()) {
Current.Type = TT_ObjCStringLiteral;
} else {
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: 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
}
}
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
/// \brief Take a guess at whether \p Tok starts a name of a function or
/// variable declaration.
///
/// This is a heuristic based on whether \p Tok is an identifier following
/// something that is likely a type.
bool isStartOfName(const FormatToken &Tok) {
[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: [Java/JS] Properly support instanceof and its precedence. llvm-svn: 241337
2015-07-03 18:12:53 +08:00
if (Tok.Previous->isOneOf(TT_LeadingJavaAnnotation, Keywords.kw_instanceof))
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.
FormatToken *PreviousNotConst = Tok.Previous;
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
while (PreviousNotConst && PreviousNotConst->is(tok::kw_const))
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
PreviousNotConst = PreviousNotConst->Previous;
[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
}
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
/// \brief Determine whether ')' is ending a cast.
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.
if (Style.Language != FormatStyle::LK_Cpp &&
Style.Language != FormatStyle::LK_Java)
return false;
// Empty parens aren't casts and there are no casts at the end of the line.
if (Tok.Previous == Tok.MatchingParen || !Tok.Next || !Tok.MatchingParen)
return false;
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: Re-add code path deleted in r253873 and add missing test. llvm-svn: 253900
2015-11-24 03:11:45 +08:00
// If there is an opening parenthesis left of the current parentheses,
// look past it as these might be chained casts.
if (LeftOfParens->is(tok::r_paren)) {
if (!LeftOfParens->MatchingParen ||
!LeftOfParens->MatchingParen->Previous)
return false;
LeftOfParens = LeftOfParens->MatchingParen->Previous;
}
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: bool b = f(g<int>)&&c; After: bool b = f(g<int>) && c; llvm-svn: 253872
2015-11-23 23:55:50 +08:00
TT_TemplateCloser))
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: 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
}
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
/// \brief 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: 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
if (!NextToken ||
NextToken->isOneOf(tok::arrow, Keywords.kw_final,
Keywords.kw_override) ||
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,
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
tok::equal, tok::kw_delete, tok::kw_sizeof) ||
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: 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
if (PrevToken->is(tok::r_paren) && PrevToken->MatchingParen &&
PrevToken->MatchingParen->Previous &&
clang-format: Fix pointer/reference detection after decltype. Before: [](const decltype(*a) & value) {} After: [](const decltype(*a)& value) {} llvm-svn: 210643
2014-06-11 15:35:16 +08:00
PrevToken->MatchingParen->Previous->isOneOf(tok::kw_typeof,
tok::kw_decltype))
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
return TT_PointerOrReference;
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: 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;
// 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;
}
/// \brief 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
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
/// \brief Parses binary expressions by inserting fake parenthesis based on
/// 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
/// \brief Parse expressions with the given operatore 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: Fix indentation of struct definitions with array init. Before: struct { int x; int y; } points[] = { {1, 2}, {2, 3}, }; After: struct { int x; int y; } points[] = { {1, 2}, {2, 3}, }; llvm-svn: 220195
2014-10-20 19:12:51 +08:00
if (!Current || (Current->closesScope() && Current->MatchingParen) ||
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()) {
while (Current && !Current->closesScope()) {
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:
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
/// \brief Gets the precedence (+1) of the given token for binary operators
/// 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: [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 (NextNonComment && NextNonComment->is(tok::colon) &&
NextNonComment->is(TT_DictLiteral))
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
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_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] 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::semi, TT_InlineASMColon, TT_SelectorName,
TT_JsComputedPropertyName) ||
(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 &&
Current->is(Keywords.kw_in))
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] 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 (Style.Language == FormatStyle::LK_Java &&
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
}
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
/// \brief Parse unary operator expressions and surround them with fake
/// parentheses if appropriate.
void parseUnaryOperator() {
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_UnaryOperator)) {
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(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;
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: 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
FormatToken *Start = 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
parseUnaryOperator();
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
// The actual precedence doesn't matter.
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
addFakeParenthesis(Start, 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) {
if (NextNonCommentLine && (*I)->First->is(tok::comment) &&
[C++11] Use 'nullptr'. llvm-svn: 208392
2014-05-09 16:15:10 +08:00
(*I)->First->Next == 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
(*I)->Level = NextNonCommentLine->Level;
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
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: 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
}
}
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();
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.
static bool isFunctionDeclarationName(const FormatToken &Current) {
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
auto skipOperatorName = [](const FormatToken* Next) -> const FormatToken* {
for (; Next; Next = Next->Next) {
if (Next->is(TT_OverloadedOperatorLParen))
return Next;
if (Next->is(TT_OverloadedOperator))
continue;
if (Next->isOneOf(tok::kw_new, tok::kw_delete)) {
// For 'new[]' and 'delete[]'.
if (Next->Next && Next->Next->is(tok::l_square) &&
Next->Next->Next && Next->Next->Next->is(tok::r_square))
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;
};
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
if (!Next || !Next->is(tok::l_paren))
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;
if (Next->Next == Next->MatchingParen)
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) {
if (Tok->is(tok::kw_const) || Tok->isSimpleTypeSpecifier() ||
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_PointerOrReference, TT_StartOfName))
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 =
Line.First->IsMultiline ? Style.ColumnLimit : 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
if (!Line.First->Next)
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
return;
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: 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 (isFunctionDeclarationName(*Current))
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);
[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: 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
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: [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: 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
if (Left.is(tok::comma) || (Right.is(tok::identifier) && Right.Next &&
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
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,
TT_ArrayInitializerLSquare))
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))
return 150;
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;
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.isOneOf(TT_RangeBasedForLoopColon, TT_InheritanceColon))
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: 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 &&
Left.Previous->isOneOf(tok::kw_if, tok::kw_for))
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: 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
Become a little smarter with formatting long chains of pipes. Assign a high penalty to breaking before "<<" if the previous token is a string literal ending in ":" or "=". Before: llvm::outs() << "aaaaaaaaaaaaaaaaa = " << aaaaaaaaaaaaaaaaa << "bbbbbbbbbbbbbbbbb = " << bbbbbbbbbbbbbbbbb << "ccccccccccccccccc = " << ccccccccccccccccc << "ddddddddddddddddd = " << ddddddddddddddddd << "eeeeeeeeeeeeeeeee = " << eeeeeeeeeeeeeeeee; After: llvm::outs() << "aaaaaaaaaaaaaaaaa = " << aaaaaaaaaaaaaaaaa << "bbbbbbbbbbbbbbbbb = " << bbbbbbbbbbbbbbbbb << "ccccccccccccccccc = " << ccccccccccccccccc << "ddddddddddddddddd = " << ddddddddddddddddd << "eeeeeeeeeeeeeeeee = " << eeeeeeeeeeeeeeeee; llvm-svn: 174545
2013-02-07 05:04:05 +08:00
if (Right.is(tok::lessless)) {
clang-format: Improve line wrapping around << operators. Generally, clang-format tries to keep label-value pairs on a single line for stream operators. However, we should not do that if there is just a single such pair, as that doesn't help much. Before: llvm::errs() << "aaaaaaaaaaaa: " << aaaaaaa(aaaaaaaaa, aaaaaaaaa); After: llvm::errs() << "aaaaaaaaaaaa: " << aaaaaaa(aaaaaaaaa, aaaaaaaaa); Also remove old test case that was testing actual behavior any more. llvm-svn: 237535
2015-05-17 15:27:09 +08:00
if (Left.is(tok::string_literal) &&
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
(Right.NextOperator || Right.OperatorIndex != 1)) {
UTF-8 support for clang-format. Summary: Detect if the file is valid UTF-8, and if this is the case, count code points instead of just using number of bytes in all (hopefully) places, where number of columns is needed. In particular, use the new FormatToken.CodePointCount instead of TokenLength where appropriate. Changed BreakableToken implementations to respect utf-8 character boundaries when in utf-8 mode. Reviewers: klimek, djasper Reviewed By: djasper CC: cfe-commits, rsmith, gribozavr Differential Revision: http://llvm-reviews.chandlerc.com/D918 llvm-svn: 183312
2013-06-05 22:09:10 +08:00
StringRef Content = Left.TokenText;
clang-format: Fix assertion on incomplete string literals. Before, this could would lead to an assert: llvm::errs() << " << a; llvm-svn: 191639
2013-09-29 20:02:57 +08:00
if (Content.startswith("\""))
Content = Content.drop_front(1);
if (Content.endswith("\""))
Content = Content.drop_back(1);
Content = Content.trim();
Slightly improve formatting of longer pipe statements. The stronger binding of a string ending in :/= does not really make sense if it is the only character. Before: llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << "=" << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; After: llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << "=" << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; llvm-svn: 177075
2013-03-14 22:00:17 +08:00
if (Content.size() > 1 &&
(Content.back() == ':' || Content.back() == '='))
Improvement of change r186320. Fixed a test that by now passed for the wrong reason. Before: llvm::outs() << "aaaaaaaaaaaaaaaaaaa: " << aaaaaaaaaaaaa( aaaaaaaaaaaaaaaaaaaaaaaaaaaa); After: llvm::outs() << "aaaaaaaaaaaaaaaaaaa: " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa); Also reformatted Format.cpp with the latest changes (1 formatting fix and 1 layout change of a <<-chain). llvm-svn: 186322
2013-07-15 22:33:14 +08:00
return 25;
Become a little smarter with formatting long chains of pipes. Assign a high penalty to breaking before "<<" if the previous token is a string literal ending in ":" or "=". Before: llvm::outs() << "aaaaaaaaaaaaaaaaa = " << aaaaaaaaaaaaaaaaa << "bbbbbbbbbbbbbbbbb = " << bbbbbbbbbbbbbbbbb << "ccccccccccccccccc = " << ccccccccccccccccc << "ddddddddddddddddd = " << ddddddddddddddddd << "eeeeeeeeeeeeeeeee = " << eeeeeeeeeeeeeeeee; After: llvm::outs() << "aaaaaaaaaaaaaaaaa = " << aaaaaaaaaaaaaaaaa << "bbbbbbbbbbbbbbbbb = " << bbbbbbbbbbbbbbbbb << "ccccccccccccccccc = " << ccccccccccccccccc << "ddddddddddddddddd = " << ddddddddddddddddd << "eeeeeeeeeeeeeeeee = " << eeeeeeeeeeeeeeeee; llvm-svn: 174545
2013-02-07 05:04:05 +08:00
}
clang-format: Improve c-style cast detection. Before: #define x ((int) - 1) #define p(q) ((int *) & q) After: #define x ((int)-1) #define p(q) ((int *)&q) llvm-svn: 186324
2013-07-15 23:04:42 +08:00
return 1; // Breaking at a << is really cheap.
Become a little smarter with formatting long chains of pipes. Assign a high penalty to breaking before "<<" if the previous token is a string literal ending in ":" or "=". Before: llvm::outs() << "aaaaaaaaaaaaaaaaa = " << aaaaaaaaaaaaaaaaa << "bbbbbbbbbbbbbbbbb = " << bbbbbbbbbbbbbbbbb << "ccccccccccccccccc = " << ccccccccccccccccc << "ddddddddddddddddd = " << ddddddddddddddddd << "eeeeeeeeeeeeeeeee = " << eeeeeeeeeeeeeeeee; After: llvm::outs() << "aaaaaaaaaaaaaaaaa = " << aaaaaaaaaaaaaaaaa << "bbbbbbbbbbbbbbbbb = " << bbbbbbbbbbbbbbbbb << "ccccccccccccccccc = " << ccccccccccccccccc << "ddddddddddddddddd = " << ddddddddddddddddd << "eeeeeeeeeeeeeeeee = " << eeeeeeeeeeeeeeeee; llvm-svn: 174545
2013-02-07 05:04:05 +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_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: Consider operator precedence as penalty when breaking before operators. This fixes llvm.org/23382. llvm-svn: 236602
2015-05-06 22:23:38 +08:00
if (Level != prec::Unknown)
return Level;
Level = Right.getPrecedence();
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: 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;
if (Right.is(tok::less) &&
clang-format: Undo r214508. It was essentially always removing the space where we already had the flag ObjCSpaceBeforeProtocolList to control it. I don't know what I was thinking. llvm-svn: 235076
2015-04-16 15:02:19 +08:00
(Left.is(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
(Line.Type == LT_ObjCDecl && Style.ObjCSpaceBeforeProtocolList)))
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 (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;
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.is(tok::less) || Right.isOneOf(tok::greater, 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
return false;
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: Support case ranges. Before (note the missing space before "..." which can lead to compile errors): switch (x) { case 'A'... 'Z': case 1... 5: break; } After: switch (x) { case 'A' ... 'Z': case 1 ... 5: break; } llvm-svn: 193050
2013-10-21 00:56:16 +08:00
return Left.Tok.isLiteral();
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: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Right.is(TT_PointerOrReference))
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 (Left.is(tok::r_paren) && Left.MatchingParen &&
(Left.MatchingParen->is(TT_OverloadedOperatorLParen) ||
(Left.MatchingParen->Previous &&
Left.MatchingParen->Previous->is(TT_FunctionDeclarationName)))) ||
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.Tok.isLiteral() ||
(!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 ||
Line.IsMultiVariableDeclStmt)));
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: 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 Right.Tok.isLiteral() ||
Right.isOneOf(TT_BlockComment, Keywords.kw_final,
Keywords.kw_override) ||
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;
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: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
return (Left.is(TT_ArrayInitializerLSquare) &&
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.SpacesInContainerLiterals && Right.isNot(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
(Left.is(TT_ArraySubscriptLSquare) && 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 &&
((Style.SpacesInContainerLiterals &&
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
Right.MatchingParen->is(TT_ArrayInitializerLSquare)) ||
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: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
Right.MatchingParen->is(TT_ArraySubscriptLSquare)));
if (Right.is(tok::l_square) &&
!Right.isOneOf(TT_ObjCMethodExpr, TT_LambdaLSquare) &&
!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: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Left.is(tok::r_paren) && Left.is(TT_AttributeParen))
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: 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))
// A.<B>DoSomething();
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;
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.
if (Style.Language == FormatStyle::LK_Cpp) {
if (Left.is(tok::kw_operator))
return Right.is(tok::coloncolon);
} else if (Style.Language == FormatStyle::LK_Proto) {
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;
} 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;
if (Left.isOneOf(Keywords.kw_let, Keywords.kw_var, Keywords.kw_in,
Keywords.kw_of) &&
(!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] 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: [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: 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::r_paren) && Right.is(tok::identifier))
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 space between ')' and <id>
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: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
if (Right.isOneOf(TT_CtorInitializerColon, 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: [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;
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: [JS] Always add space after fat arrow. Before: return () =>[]; After: return () => []; llvm-svn: 238875
2015-06-03 06:06:07 +08:00
if (Left.is(tok::greater) && Right.is(tok::greater))
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: 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.isOneOf(tok::arrow, tok::period, tok::arrowstar, tok::periodstar) ||
Left.isOneOf(tok::arrow, tok::period, tok::arrowstar, tok::periodstar))
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: [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 (Right.is(tok::coloncolon) && Left.isNot(tok::l_brace))
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) ||
Fix formatting of fully qualified names in array subscripts. Before: a[ ::b::c]; After: a[::b::c]; llvm-svn: 258123
2016-01-19 22:05:32 +08:00
!(Left.isOneOf(tok::identifier, tok::l_paren, tok::r_paren,
tok::l_square) ||
clang-format: Refactoring. Re-apply r222638 and r222641 without variadic templates. llvm-svn: 222747
2014-11-25 18:05:17 +08:00
Left.isOneOf(TT_TemplateCloser, TT_TemplateOpener));
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: 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) ||
Line.startsWith(tok::kw_export, tok::kw_enum)))
// 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 &&
Style.AllowShortFunctionsOnASingleLine ==
FormatStyle::SFS_Inline);
} 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: 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
// If the last token before a '}' is a comma or a trailing comment, the
// intention is to insert a line break after it in order to make shuffling
// around entries easier.
const FormatToken *BeforeClosingBrace = nullptr;
clang-format: Make trailing commas in array inits force one per line. Before: NSArray *array = @[ @"a", @"a", ]; After: NSArray *array = @[ @"a", @"a", ]; llvm-svn: 230741
2015-02-27 16:41:05 +08:00
if (Left.isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) &&
Left.BlockKind != BK_Block && Left.MatchingParen)
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
BeforeClosingBrace = Left.MatchingParen->Previous;
clang-format: Make trailing commas in array inits force one per line. Before: NSArray *array = @[ @"a", @"a", ]; After: NSArray *array = @[ @"a", @"a", ]; llvm-svn: 230741
2015-02-27 16:41:05 +08:00
else if (Right.MatchingParen &&
Right.MatchingParen->isOneOf(tok::l_brace,
TT_ArrayInitializerLSquare))
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
BeforeClosingBrace = &Left;
if (BeforeClosingBrace && (BeforeClosingBrace->is(tok::comma) ||
BeforeClosingBrace->isTrailingComment()))
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::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: 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.isStringLiteral() &&
(Right.isStringLiteral() || Right.is(TT_ObjCStringLiteral)))
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->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 &&
Style.AlwaysBreakTemplateDeclarations)
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.isOneOf(TT_CtorInitializerComma, TT_CtorInitializerColon)) &&
Style.BreakConstructorInitializersBeforeComma &&
!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: 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: Improve handling of raw string literals. Especially try to keep existing line breaks before raw string literals, as the code author might have aligned content to it. Thereby, clang-format now keeps things like: parseStyle(R"( BasedOnStyle: Google, ColumnLimit: 100)"); parseStyle( R"(BasedOnStyle: Google, ColumnLimit: 100)"); llvm-svn: 197368
2013-12-16 15:23:08 +08:00
// 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.NewlinesBefore > 0;
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->is(tok::l_brace) && Right.NestingLevel == 1 &&
Style.Language == FormatStyle::LK_Proto)
clang-format: [Proto] Change formatting text-formatted options. Before: optional Type type = 1 [(mutate_options) = {vital : true abc : false}]; After: optional Type type = 1 [(mutate_options) = { vital : true abc : false }]; llvm-svn: 220679
2014-10-27 21:25:59 +08:00
// Don't put enums 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: 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) ||
(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 (Style.Language == FormatStyle::LK_Proto && Left.isNot(tok::l_brace) &&
Right.is(TT_SelectorName))
clang-format: [proto] Improve formatting of text-proto options. Initial patch and tests by Kaushik Sridharan, thank you! llvm-svn: 214084
2014-07-28 22:08:09 +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 (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: 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] Fix incorrect line break leading to semicolon insertion. clang-format only works for JavaScript code, if all the semicolons are present anyway, so this linebreak can never be desired. Before (with appropriate statement lengths or column limit): return [ aaa ]; After: return [ aaaa ]; llvm-svn: 257741
2016-01-14 13:37:52 +08:00
if (Left.is(tok::kw_return))
return false; // Otherwise a semicolon is inserted.
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] 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 (Right.NestingLevel == 0 && Right.is(Keywords.kw_is))
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: [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.
return Left.BlockKind == BK_BracedInit;
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: 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: Fix formatting of class template declaration. Before: template <class R, class C> struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const> : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {}; After: template <class R, class C> struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const> : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {}; llvm-svn: 201424
2014-02-15 02:22:40 +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(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: 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.isOneOf(TT_DictLiteral, 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
return true;
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: 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: 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
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
if (Right.is(tok::kw___attribute))
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: 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: 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
Style.BreakConstructorInitializersBeforeComma)
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: 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
Style.BreakConstructorInitializersBeforeComma)
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;
return Left.isOneOf(tok::comma, tok::coloncolon, tok::semi, tok::l_brace,
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
tok::kw_class, tok::kw_struct) ||
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: 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.is(tok::l_paren) && !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
}
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) {
llvm::errs() << "AnnotatedTokens:\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
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
<< " P=" << Tok->SplitPenalty << " Name=" << Tok->Tok.getName()
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
<< " 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] << "/";
llvm::errs() << " FakeRParens=" << Tok->FakeRParens << "\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