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

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

750 lines
25 KiB
C++
Raw Normal View History

clang-format: Add initial #include sorting capabilities. To implement this nicely, add a function that merges two sets of replacements that are meant to be done in sequence. This functionality will also be useful for other applications, e.g. formatting the result of clang-tidy fixes. llvm-svn: 248367
2015-09-23 16:30:47 +08:00
//===- unittest/Format/SortIncludesTest.cpp - Include sort unit tests -----===//
//
Update the file headers across all of the LLVM projects in the monorepo to reflect the new license. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. llvm-svn: 351636
2019-01-19 16:50:56 +08:00
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
clang-format: Add initial #include sorting capabilities. To implement this nicely, add a function that merges two sets of replacements that are meant to be done in sequence. This functionality will also be useful for other applications, e.g. formatting the result of clang-tidy fixes. llvm-svn: 248367
2015-09-23 16:30:47 +08:00
//
//===----------------------------------------------------------------------===//
#include "FormatTestUtils.h"
#include "clang/Format/Format.h"
[clang-format] Do not emit replacements while regrouping if Cpp includes are OK Summary: Currently clang-format would always emit a replacement for multi-block #include sections if `IBS_Regroup`, even if the sections are correct: ``` % cat ~/test.h #include <a.h> #include "b.h" % bin/clang-format --output-replacements-xml -style=google ~/test.h <?xml version='1.0'?> <replacements xml:space='preserve' incomplete_format='false'> <replacement offset='0' length='30'>#include &lt;a.h>&#10;&#10;#include "b.h"</replacement> </replacements> % ``` This change makes clang-format not emit replacements in this case. The logic is similar to the one implemented for Java in r354452. Reviewers: ioeric Reviewed By: ioeric Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D60199 llvm-svn: 357599
2019-04-03 23:16:04 +08:00
#include "llvm/ADT/None.h"
clang-format: Add initial #include sorting capabilities. To implement this nicely, add a function that merges two sets of replacements that are meant to be done in sequence. This functionality will also be useful for other applications, e.g. formatting the result of clang-tidy fixes. llvm-svn: 248367
2015-09-23 16:30:47 +08:00
#include "llvm/Support/Debug.h"
#include "gtest/gtest.h"
#define DEBUG_TYPE "format-test"
namespace clang {
namespace format {
namespace {
class SortIncludesTest : public ::testing::Test {
protected:
clang-format: Use stable_sort when sorting #includes. Otherwise, clang-format can output useless replacements in the presence of identical #includes llvm-svn: 262630
2016-03-04 01:34:14 +08:00
std::vector<tooling::Range> GetCodeRange(StringRef Code) {
return std::vector<tooling::Range>(1, tooling::Range(0, Code.size()));
}
clang-format: Correctly calculate affected ranges when sorting #includes. affectedRanges takes a start and an end offset, not offset and length. llvm-svn: 280165
2016-08-31 05:33:41 +08:00
std::string sort(StringRef Code, std::vector<tooling::Range> Ranges,
[clang-format] Do not emit replacements while regrouping if Cpp includes are OK Summary: Currently clang-format would always emit a replacement for multi-block #include sections if `IBS_Regroup`, even if the sections are correct: ``` % cat ~/test.h #include <a.h> #include "b.h" % bin/clang-format --output-replacements-xml -style=google ~/test.h <?xml version='1.0'?> <replacements xml:space='preserve' incomplete_format='false'> <replacement offset='0' length='30'>#include &lt;a.h>&#10;&#10;#include "b.h"</replacement> </replacements> % ``` This change makes clang-format not emit replacements in this case. The logic is similar to the one implemented for Java in r354452. Reviewers: ioeric Reviewed By: ioeric Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D60199 llvm-svn: 357599
2019-04-03 23:16:04 +08:00
StringRef FileName = "input.cc",
unsigned ExpectedNumRanges = 1) {
[clang-format] Move #include related style to libToolingCore Summary: This will be shared by include insertion/deletion library. Reviewers: ilya-biryukov Reviewed By: ilya-biryukov Subscribers: mgorny, klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D46758 llvm-svn: 332284
2018-05-15 03:51:33 +08:00
auto Replaces = sortIncludes(FmtStyle, Code, Ranges, FileName);
Make clang-format remove duplicate headers when sorting #includes. Summary: When sorting #includes, #include directives that have the same text will be deduplicated when sorting #includes, and only the first #include in the duplicate #includes remains. If the `Cursor` is provided and put on a deleted #include, it will be put on the remaining #include in the duplicate #includes. Reviewers: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D23274 llvm-svn: 278206
2016-08-10 17:32:23 +08:00
Ranges = tooling::calculateRangesAfterReplacements(Replaces, Ranges);
[clang-format] Do not emit replacements while regrouping if Cpp includes are OK Summary: Currently clang-format would always emit a replacement for multi-block #include sections if `IBS_Regroup`, even if the sections are correct: ``` % cat ~/test.h #include <a.h> #include "b.h" % bin/clang-format --output-replacements-xml -style=google ~/test.h <?xml version='1.0'?> <replacements xml:space='preserve' incomplete_format='false'> <replacement offset='0' length='30'>#include &lt;a.h>&#10;&#10;#include "b.h"</replacement> </replacements> % ``` This change makes clang-format not emit replacements in this case. The logic is similar to the one implemented for Java in r354452. Reviewers: ioeric Reviewed By: ioeric Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D60199 llvm-svn: 357599
2019-04-03 23:16:04 +08:00
EXPECT_EQ(ExpectedNumRanges, Replaces.size());
Make clang-format remove duplicate headers when sorting #includes. Summary: When sorting #includes, #include directives that have the same text will be deduplicated when sorting #includes, and only the first #include in the duplicate #includes remains. If the `Cursor` is provided and put on a deleted #include, it will be put on the remaining #include in the duplicate #includes. Reviewers: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D23274 llvm-svn: 278206
2016-08-10 17:32:23 +08:00
auto Sorted = applyAllReplacements(Code, Replaces);
Make tooling::applyAllReplacements return llvm::Expected<string> instead of empty string to indicate potential error. Summary: return llvm::Expected<> to carry error status and error information. This is the first step towards introducing "Error" into tooling::Replacements. Reviewers: djasper, klimek Subscribers: ioeric, klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D21601 llvm-svn: 275062
2016-07-11 21:53:12 +08:00
EXPECT_TRUE(static_cast<bool>(Sorted));
auto Result = applyAllReplacements(
[clang-format] Move #include related style to libToolingCore Summary: This will be shared by include insertion/deletion library. Reviewers: ilya-biryukov Reviewed By: ilya-biryukov Subscribers: mgorny, klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D46758 llvm-svn: 332284
2018-05-15 03:51:33 +08:00
*Sorted, reformat(FmtStyle, *Sorted, Ranges, FileName));
Make tooling::applyAllReplacements return llvm::Expected<string> instead of empty string to indicate potential error. Summary: return llvm::Expected<> to carry error status and error information. This is the first step towards introducing "Error" into tooling::Replacements. Reviewers: djasper, klimek Subscribers: ioeric, klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D21601 llvm-svn: 275062
2016-07-11 21:53:12 +08:00
EXPECT_TRUE(static_cast<bool>(Result));
return *Result;
clang-format: Add initial #include sorting capabilities. To implement this nicely, add a function that merges two sets of replacements that are meant to be done in sequence. This functionality will also be useful for other applications, e.g. formatting the result of clang-tidy fixes. llvm-svn: 248367
2015-09-23 16:30:47 +08:00
}
clang-format: Extend #include sorting functionality Recognize the main module header as well as different #include categories. This should now mimic the behavior of llvm/utils/sort_includes.py as well as clang-tools-extra/clang-tidy/llvm/IncludeOrderCheck.cpp very closely. llvm-svn: 248782
2015-09-29 15:53:08 +08:00
[clang-format] Do not emit replacements while regrouping if Cpp includes are OK Summary: Currently clang-format would always emit a replacement for multi-block #include sections if `IBS_Regroup`, even if the sections are correct: ``` % cat ~/test.h #include <a.h> #include "b.h" % bin/clang-format --output-replacements-xml -style=google ~/test.h <?xml version='1.0'?> <replacements xml:space='preserve' incomplete_format='false'> <replacement offset='0' length='30'>#include &lt;a.h>&#10;&#10;#include "b.h"</replacement> </replacements> % ``` This change makes clang-format not emit replacements in this case. The logic is similar to the one implemented for Java in r354452. Reviewers: ioeric Reviewed By: ioeric Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D60199 llvm-svn: 357599
2019-04-03 23:16:04 +08:00
std::string sort(StringRef Code,
StringRef FileName = "input.cpp",
unsigned ExpectedNumRanges = 1) {
return sort(Code, GetCodeRange(Code), FileName, ExpectedNumRanges);
clang-format: Correctly calculate affected ranges when sorting #includes. affectedRanges takes a start and an end offset, not offset and length. llvm-svn: 280165
2016-08-31 05:33:41 +08:00
}
clang-format: Make moving of the Cursor work properly when sorting #includes. llvm-svn: 253860
2015-11-23 16:36:35 +08:00
unsigned newCursor(llvm::StringRef Code, unsigned Cursor) {
[clang-format] Move #include related style to libToolingCore Summary: This will be shared by include insertion/deletion library. Reviewers: ilya-biryukov Reviewed By: ilya-biryukov Subscribers: mgorny, klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D46758 llvm-svn: 332284
2018-05-15 03:51:33 +08:00
sortIncludes(FmtStyle, Code, GetCodeRange(Code), "input.cpp", &Cursor);
clang-format: Make moving of the Cursor work properly when sorting #includes. llvm-svn: 253860
2015-11-23 16:36:35 +08:00
return Cursor;
}
[clang-format] Move #include related style to libToolingCore Summary: This will be shared by include insertion/deletion library. Reviewers: ilya-biryukov Reviewed By: ilya-biryukov Subscribers: mgorny, klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D46758 llvm-svn: 332284
2018-05-15 03:51:33 +08:00
FormatStyle FmtStyle = getLLVMStyle();
tooling::IncludeStyle &Style = FmtStyle.IncludeStyle;
clang-format: Add initial #include sorting capabilities. To implement this nicely, add a function that merges two sets of replacements that are meant to be done in sequence. This functionality will also be useful for other applications, e.g. formatting the result of clang-tidy fixes. llvm-svn: 248367
2015-09-23 16:30:47 +08:00
};
TEST_F(SortIncludesTest, BasicSorting) {
EXPECT_EQ("#include \"a.h\"\n"
"#include \"b.h\"\n"
"#include \"c.h\"\n",
sort("#include \"a.h\"\n"
"#include \"c.h\"\n"
"#include \"b.h\"\n"));
clang-format: Correctly calculate affected ranges when sorting #includes. affectedRanges takes a start and an end offset, not offset and length. llvm-svn: 280165
2016-08-31 05:33:41 +08:00
EXPECT_EQ("// comment\n"
"#include <a>\n"
"#include <b>\n",
sort("// comment\n"
"#include <b>\n"
"#include <a>\n",
{tooling::Range(25, 1)}));
clang-format: Add initial #include sorting capabilities. To implement this nicely, add a function that merges two sets of replacements that are meant to be done in sequence. This functionality will also be useful for other applications, e.g. formatting the result of clang-tidy fixes. llvm-svn: 248367
2015-09-23 16:30:47 +08:00
}
[clang-format] Modified SortIncludes and IncludeCategories to priority for sorting #includes within the Group Category. Summary: This new Style rule is made as a part of adding support for NetBSD KNF in clang-format. NetBSD have it's own priority of includes which should be followed while formatting NetBSD code. This style sorts the Cpp Includes according to the priorities of NetBSD, as mentioned in the [Style Guide](http://cvsweb.netbsd.org/bsdweb.cgi/src/share/misc/style?rev=HEAD&content-type=text/x-cvsweb-markup) The working of this Style rule shown below: **Configuration:** This revision introduces a new field under IncludeCategories named `SortPriority` which defines the priority of ordering the `#includes` and the `Priority` will define the categories for grouping the `#include blocks`. Reviewers: cfe-commits, mgorny, christos, MyDeveloperDay Reviewed By: MyDeveloperDay Subscribers: lebedev.ri, rdwampler, christos, mgorny, krytarowski Patch By: Manikishan Tags: #clang, #clang-format Differential Revision: https://reviews.llvm.org/D64695 llvm-svn: 372919
2019-09-26 04:33:01 +08:00
TEST_F(SortIncludesTest, SortedIncludesUsingSortPriorityAttribute) {
FmtStyle.IncludeStyle.IncludeBlocks = tooling::IncludeStyle::IBS_Regroup;
FmtStyle.IncludeStyle.IncludeCategories = {
{"^<sys/param\\.h>", 1, 0},
{"^<sys/types\\.h>", 1, 1},
{"^<sys.*/", 1, 2},
{"^<uvm/", 2, 3},
{"^<machine/", 3, 4},
{"^<dev/", 4, 5},
{"^<net.*/", 5, 6},
{"^<protocols/", 5, 7},
{"^<(fs|miscfs|msdosfs|nfs|ntfs|ufs)/", 6, 8},
{"^<(x86|amd64|i386|xen)/", 7, 8},
{"<path", 9, 11},
{"^<[^/].*\\.h>", 8, 10},
{"^\".*\\.h\"", 10, 12}};
EXPECT_EQ("#include <sys/param.h>\n"
"#include <sys/types.h>\n"
"#include <sys/ioctl.h>\n"
"#include <sys/socket.h>\n"
"#include <sys/stat.h>\n"
"#include <sys/wait.h>\n"
"\n"
"#include <net/if.h>\n"
"#include <net/if_dl.h>\n"
"#include <net/route.h>\n"
"#include <netinet/in.h>\n"
"#include <protocols/rwhod.h>\n"
"\n"
"#include <assert.h>\n"
"#include <errno.h>\n"
"#include <inttypes.h>\n"
"#include <stdio.h>\n"
"#include <stdlib.h>\n"
"\n"
"#include <paths.h>\n"
"\n"
"#include \"pathnames.h\"\n",
sort("#include <sys/param.h>\n"
"#include <sys/types.h>\n"
"#include <sys/ioctl.h>\n"
"#include <net/if_dl.h>\n"
"#include <net/route.h>\n"
"#include <netinet/in.h>\n"
"#include <sys/socket.h>\n"
"#include <sys/stat.h>\n"
"#include <sys/wait.h>\n"
"#include <net/if.h>\n"
"#include <protocols/rwhod.h>\n"
"#include <assert.h>\n"
"#include <paths.h>\n"
"#include \"pathnames.h\"\n"
"#include <errno.h>\n"
"#include <inttypes.h>\n"
"#include <stdio.h>\n"
"#include <stdlib.h>\n"));
}
TEST_F(SortIncludesTest, SortPriorityNotDefined) {
FmtStyle = getLLVMStyle();
EXPECT_EQ("#include \"FormatTestUtils.h\"\n"
"#include \"clang/Format/Format.h\"\n"
"#include \"llvm/ADT/None.h\"\n"
"#include \"llvm/Support/Debug.h\"\n"
"#include \"gtest/gtest.h\"\n",
sort("#include \"clang/Format/Format.h\"\n"
"#include \"llvm/ADT/None.h\"\n"
"#include \"FormatTestUtils.h\"\n"
"#include \"gtest/gtest.h\"\n"
"#include \"llvm/Support/Debug.h\"\n"));
}
clang-format: Use stable_sort when sorting #includes. Otherwise, clang-format can output useless replacements in the presence of identical #includes llvm-svn: 262630
2016-03-04 01:34:14 +08:00
TEST_F(SortIncludesTest, NoReplacementsForValidIncludes) {
// Identical #includes have led to a failure with an unstable sort.
std::string Code = "#include <a>\n"
"#include <b>\n"
Make clang-format remove duplicate headers when sorting #includes. Summary: When sorting #includes, #include directives that have the same text will be deduplicated when sorting #includes, and only the first #include in the duplicate #includes remains. If the `Cursor` is provided and put on a deleted #include, it will be put on the remaining #include in the duplicate #includes. Reviewers: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D23274 llvm-svn: 278206
2016-08-10 17:32:23 +08:00
"#include <c>\n"
"#include <d>\n"
"#include <e>\n"
"#include <f>\n";
[clang-format] Move #include related style to libToolingCore Summary: This will be shared by include insertion/deletion library. Reviewers: ilya-biryukov Reviewed By: ilya-biryukov Subscribers: mgorny, klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D46758 llvm-svn: 332284
2018-05-15 03:51:33 +08:00
EXPECT_TRUE(sortIncludes(FmtStyle, Code, GetCodeRange(Code), "a.cc").empty());
clang-format: Use stable_sort when sorting #includes. Otherwise, clang-format can output useless replacements in the presence of identical #includes llvm-svn: 262630
2016-03-04 01:34:14 +08:00
}
[clang-format] Add option to group multiple #include blocks when sorting includes Summary: This patch allows grouping multiple #include blocks together and sort all includes as one big block. Additionally, sorted includes can be regrouped after sorting based on configured categories. Contributed by @KrzysztofKapusta! Reviewers: krasimir Reviewed By: krasimir Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D40288 llvm-svn: 319024
2017-11-27 21:23:45 +08:00
TEST_F(SortIncludesTest, SortedIncludesInMultipleBlocksAreMerged) {
[clang-format] Move #include related style to libToolingCore Summary: This will be shared by include insertion/deletion library. Reviewers: ilya-biryukov Reviewed By: ilya-biryukov Subscribers: mgorny, klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D46758 llvm-svn: 332284
2018-05-15 03:51:33 +08:00
Style.IncludeBlocks = tooling::IncludeStyle::IBS_Merge;
[clang-format] Add option to group multiple #include blocks when sorting includes Summary: This patch allows grouping multiple #include blocks together and sort all includes as one big block. Additionally, sorted includes can be regrouped after sorting based on configured categories. Contributed by @KrzysztofKapusta! Reviewers: krasimir Reviewed By: krasimir Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D40288 llvm-svn: 319024
2017-11-27 21:23:45 +08:00
EXPECT_EQ("#include \"a.h\"\n"
"#include \"b.h\"\n"
"#include \"c.h\"\n",
sort("#include \"a.h\"\n"
"#include \"c.h\"\n"
"\n"
"\n"
"#include \"b.h\"\n"));
[clang-format] Move #include related style to libToolingCore Summary: This will be shared by include insertion/deletion library. Reviewers: ilya-biryukov Reviewed By: ilya-biryukov Subscribers: mgorny, klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D46758 llvm-svn: 332284
2018-05-15 03:51:33 +08:00
Style.IncludeBlocks = tooling::IncludeStyle::IBS_Regroup;
[clang-format] Add option to group multiple #include blocks when sorting includes Summary: This patch allows grouping multiple #include blocks together and sort all includes as one big block. Additionally, sorted includes can be regrouped after sorting based on configured categories. Contributed by @KrzysztofKapusta! Reviewers: krasimir Reviewed By: krasimir Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D40288 llvm-svn: 319024
2017-11-27 21:23:45 +08:00
EXPECT_EQ("#include \"a.h\"\n"
"#include \"b.h\"\n"
"#include \"c.h\"\n",
sort("#include \"a.h\"\n"
"#include \"c.h\"\n"
"\n"
"\n"
"#include \"b.h\"\n"));
}
clang-format: Make sorting includes respect // clang-format off llvm-svn: 253772
2015-11-21 17:17:08 +08:00
TEST_F(SortIncludesTest, SupportClangFormatOff) {
EXPECT_EQ("#include <a>\n"
"#include <b>\n"
"#include <c>\n"
"// clang-format off\n"
"#include <b>\n"
"#include <a>\n"
"#include <c>\n"
"// clang-format on\n",
sort("#include <b>\n"
"#include <a>\n"
"#include <c>\n"
"// clang-format off\n"
"#include <b>\n"
"#include <a>\n"
"#include <c>\n"
"// clang-format on\n"));
}
[clang-format] clang-format off/on not respected when using C Style comments Summary: If the clang-format on/off is in a /* comment */ then the sorting of headers is not ignored PR40901 - https://bugs.llvm.org/show_bug.cgi?id=40901 Reviewers: djasper, klimek, JonasToth, krasimir, alexfh Reviewed By: alexfh Subscribers: alexfh, cfe-commits, llvm-commits Tags: #clang, #clang-tools-extra Differential Revision: https://reviews.llvm.org/D58819 llvm-svn: 355266
2019-03-02 17:08:51 +08:00
TEST_F(SortIncludesTest, SupportClangFormatOffCStyle) {
EXPECT_EQ("#include <a>\n"
"#include <b>\n"
"#include <c>\n"
"/* clang-format off */\n"
"#include <b>\n"
"#include <a>\n"
"#include <c>\n"
"/* clang-format on */\n",
sort("#include <b>\n"
"#include <a>\n"
"#include <c>\n"
"/* clang-format off */\n"
"#include <b>\n"
"#include <a>\n"
"#include <c>\n"
"/* clang-format on */\n"));
// Not really turning it off
EXPECT_EQ("#include <a>\n"
"#include <b>\n"
"#include <c>\n"
"/* clang-format offically */\n"
"#include <a>\n"
"#include <b>\n"
"#include <c>\n"
"/* clang-format onwards */\n",
sort("#include <b>\n"
"#include <a>\n"
"#include <c>\n"
"/* clang-format offically */\n"
"#include <b>\n"
"#include <a>\n"
"#include <c>\n"
[clang-format] Do not emit replacements while regrouping if Cpp includes are OK Summary: Currently clang-format would always emit a replacement for multi-block #include sections if `IBS_Regroup`, even if the sections are correct: ``` % cat ~/test.h #include <a.h> #include "b.h" % bin/clang-format --output-replacements-xml -style=google ~/test.h <?xml version='1.0'?> <replacements xml:space='preserve' incomplete_format='false'> <replacement offset='0' length='30'>#include &lt;a.h>&#10;&#10;#include "b.h"</replacement> </replacements> % ``` This change makes clang-format not emit replacements in this case. The logic is similar to the one implemented for Java in r354452. Reviewers: ioeric Reviewed By: ioeric Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D60199 llvm-svn: 357599
2019-04-03 23:16:04 +08:00
"/* clang-format onwards */\n", "input.h", 2));
[clang-format] clang-format off/on not respected when using C Style comments Summary: If the clang-format on/off is in a /* comment */ then the sorting of headers is not ignored PR40901 - https://bugs.llvm.org/show_bug.cgi?id=40901 Reviewers: djasper, klimek, JonasToth, krasimir, alexfh Reviewed By: alexfh Subscribers: alexfh, cfe-commits, llvm-commits Tags: #clang, #clang-tools-extra Differential Revision: https://reviews.llvm.org/D58819 llvm-svn: 355266
2019-03-02 17:08:51 +08:00
}
clang-format: Enable #include sorting by default. This has seen quite some usage and I am not aware of any issues. Also add a style option to enable/disable include sorting. The existing command line flag can from now on be used to override whatever is set in the style. llvm-svn: 253202
2015-11-16 20:38:56 +08:00
TEST_F(SortIncludesTest, IncludeSortingCanBeDisabled) {
[clang-format] Move #include related style to libToolingCore Summary: This will be shared by include insertion/deletion library. Reviewers: ilya-biryukov Reviewed By: ilya-biryukov Subscribers: mgorny, klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D46758 llvm-svn: 332284
2018-05-15 03:51:33 +08:00
FmtStyle.SortIncludes = false;
clang-format: Enable #include sorting by default. This has seen quite some usage and I am not aware of any issues. Also add a style option to enable/disable include sorting. The existing command line flag can from now on be used to override whatever is set in the style. llvm-svn: 253202
2015-11-16 20:38:56 +08:00
EXPECT_EQ("#include \"a.h\"\n"
"#include \"c.h\"\n"
"#include \"b.h\"\n",
sort("#include \"a.h\"\n"
"#include \"c.h\"\n"
[clang-format] Do not emit replacements while regrouping if Cpp includes are OK Summary: Currently clang-format would always emit a replacement for multi-block #include sections if `IBS_Regroup`, even if the sections are correct: ``` % cat ~/test.h #include <a.h> #include "b.h" % bin/clang-format --output-replacements-xml -style=google ~/test.h <?xml version='1.0'?> <replacements xml:space='preserve' incomplete_format='false'> <replacement offset='0' length='30'>#include &lt;a.h>&#10;&#10;#include "b.h"</replacement> </replacements> % ``` This change makes clang-format not emit replacements in this case. The logic is similar to the one implemented for Java in r354452. Reviewers: ioeric Reviewed By: ioeric Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D60199 llvm-svn: 357599
2019-04-03 23:16:04 +08:00
"#include \"b.h\"\n",
"input.h", 0));
clang-format: Enable #include sorting by default. This has seen quite some usage and I am not aware of any issues. Also add a style option to enable/disable include sorting. The existing command line flag can from now on be used to override whatever is set in the style. llvm-svn: 253202
2015-11-16 20:38:56 +08:00
}
clang-format: Teach --sort-includes to interleave #include and #import. clang accepts both #include and #import for includes (the latter having an implicit header guard). Let clang-format interleave both types if --sort-includes is passed. #import is used frequently in Objective-C code. http://reviews.llvm.org/D13853 llvm-svn: 250909
2015-10-22 01:13:45 +08:00
TEST_F(SortIncludesTest, MixIncludeAndImport) {
EXPECT_EQ("#include \"a.h\"\n"
"#import \"b.h\"\n"
"#include \"c.h\"\n",
sort("#include \"a.h\"\n"
"#include \"c.h\"\n"
"#import \"b.h\"\n"));
}
clang-format: Add initial #include sorting capabilities. To implement this nicely, add a function that merges two sets of replacements that are meant to be done in sequence. This functionality will also be useful for other applications, e.g. formatting the result of clang-tidy fixes. llvm-svn: 248367
2015-09-23 16:30:47 +08:00
TEST_F(SortIncludesTest, FixTrailingComments) {
EXPECT_EQ("#include \"a.h\" // comment\n"
"#include \"bb.h\" // comment\n"
"#include \"ccc.h\"\n",
sort("#include \"a.h\" // comment\n"
"#include \"ccc.h\"\n"
"#include \"bb.h\" // comment\n"));
}
TEST_F(SortIncludesTest, LeadingWhitespace) {
EXPECT_EQ("#include \"a.h\"\n"
"#include \"b.h\"\n"
"#include \"c.h\"\n",
sort(" #include \"a.h\"\n"
" #include \"c.h\"\n"
" #include \"b.h\"\n"));
EXPECT_EQ("#include \"a.h\"\n"
"#include \"b.h\"\n"
"#include \"c.h\"\n",
sort("# include \"a.h\"\n"
"# include \"c.h\"\n"
"# include \"b.h\"\n"));
}
TEST_F(SortIncludesTest, GreaterInComment) {
EXPECT_EQ("#include \"a.h\"\n"
"#include \"b.h\" // >\n"
"#include \"c.h\"\n",
sort("#include \"a.h\"\n"
"#include \"c.h\"\n"
"#include \"b.h\" // >\n"));
}
TEST_F(SortIncludesTest, SortsLocallyInEachBlock) {
EXPECT_EQ("#include \"a.h\"\n"
"#include \"c.h\"\n"
"\n"
"#include \"b.h\"\n",
clang-format: Extend #include sorting functionality Recognize the main module header as well as different #include categories. This should now mimic the behavior of llvm/utils/sort_includes.py as well as clang-tools-extra/clang-tidy/llvm/IncludeOrderCheck.cpp very closely. llvm-svn: 248782
2015-09-29 15:53:08 +08:00
sort("#include \"a.h\"\n"
"#include \"c.h\"\n"
clang-format: Add initial #include sorting capabilities. To implement this nicely, add a function that merges two sets of replacements that are meant to be done in sequence. This functionality will also be useful for other applications, e.g. formatting the result of clang-tidy fixes. llvm-svn: 248367
2015-09-23 16:30:47 +08:00
"\n"
[clang-format] Do not emit replacements while regrouping if Cpp includes are OK Summary: Currently clang-format would always emit a replacement for multi-block #include sections if `IBS_Regroup`, even if the sections are correct: ``` % cat ~/test.h #include <a.h> #include "b.h" % bin/clang-format --output-replacements-xml -style=google ~/test.h <?xml version='1.0'?> <replacements xml:space='preserve' incomplete_format='false'> <replacement offset='0' length='30'>#include &lt;a.h>&#10;&#10;#include "b.h"</replacement> </replacements> % ``` This change makes clang-format not emit replacements in this case. The logic is similar to the one implemented for Java in r354452. Reviewers: ioeric Reviewed By: ioeric Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D60199 llvm-svn: 357599
2019-04-03 23:16:04 +08:00
"#include \"b.h\"\n", "input.h", 0));
clang-format: Add initial #include sorting capabilities. To implement this nicely, add a function that merges two sets of replacements that are meant to be done in sequence. This functionality will also be useful for other applications, e.g. formatting the result of clang-tidy fixes. llvm-svn: 248367
2015-09-23 16:30:47 +08:00
}
[clang-format] Add option to group multiple #include blocks when sorting includes Summary: This patch allows grouping multiple #include blocks together and sort all includes as one big block. Additionally, sorted includes can be regrouped after sorting based on configured categories. Contributed by @KrzysztofKapusta! Reviewers: krasimir Reviewed By: krasimir Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D40288 llvm-svn: 319024
2017-11-27 21:23:45 +08:00
TEST_F(SortIncludesTest, SortsAllBlocksWhenMerging) {
[clang-format] Move #include related style to libToolingCore Summary: This will be shared by include insertion/deletion library. Reviewers: ilya-biryukov Reviewed By: ilya-biryukov Subscribers: mgorny, klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D46758 llvm-svn: 332284
2018-05-15 03:51:33 +08:00
Style.IncludeBlocks = tooling::IncludeStyle::IBS_Merge;
[clang-format] Add option to group multiple #include blocks when sorting includes Summary: This patch allows grouping multiple #include blocks together and sort all includes as one big block. Additionally, sorted includes can be regrouped after sorting based on configured categories. Contributed by @KrzysztofKapusta! Reviewers: krasimir Reviewed By: krasimir Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D40288 llvm-svn: 319024
2017-11-27 21:23:45 +08:00
EXPECT_EQ("#include \"a.h\"\n"
"#include \"b.h\"\n"
"#include \"c.h\"\n",
sort("#include \"a.h\"\n"
"#include \"c.h\"\n"
"\n"
"#include \"b.h\"\n"));
}
TEST_F(SortIncludesTest, CommentsAlwaysSeparateGroups) {
EXPECT_EQ("#include \"a.h\"\n"
"#include \"c.h\"\n"
"// comment\n"
"#include \"b.h\"\n",
sort("#include \"c.h\"\n"
"#include \"a.h\"\n"
"// comment\n"
"#include \"b.h\"\n"));
[clang-format] Move #include related style to libToolingCore Summary: This will be shared by include insertion/deletion library. Reviewers: ilya-biryukov Reviewed By: ilya-biryukov Subscribers: mgorny, klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D46758 llvm-svn: 332284
2018-05-15 03:51:33 +08:00
Style.IncludeBlocks = tooling::IncludeStyle::IBS_Merge;
[clang-format] Add option to group multiple #include blocks when sorting includes Summary: This patch allows grouping multiple #include blocks together and sort all includes as one big block. Additionally, sorted includes can be regrouped after sorting based on configured categories. Contributed by @KrzysztofKapusta! Reviewers: krasimir Reviewed By: krasimir Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D40288 llvm-svn: 319024
2017-11-27 21:23:45 +08:00
EXPECT_EQ("#include \"a.h\"\n"
"#include \"c.h\"\n"
"// comment\n"
"#include \"b.h\"\n",
sort("#include \"c.h\"\n"
"#include \"a.h\"\n"
"// comment\n"
"#include \"b.h\"\n"));
[clang-format] Move #include related style to libToolingCore Summary: This will be shared by include insertion/deletion library. Reviewers: ilya-biryukov Reviewed By: ilya-biryukov Subscribers: mgorny, klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D46758 llvm-svn: 332284
2018-05-15 03:51:33 +08:00
Style.IncludeBlocks = tooling::IncludeStyle::IBS_Regroup;
[clang-format] Add option to group multiple #include blocks when sorting includes Summary: This patch allows grouping multiple #include blocks together and sort all includes as one big block. Additionally, sorted includes can be regrouped after sorting based on configured categories. Contributed by @KrzysztofKapusta! Reviewers: krasimir Reviewed By: krasimir Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D40288 llvm-svn: 319024
2017-11-27 21:23:45 +08:00
EXPECT_EQ("#include \"a.h\"\n"
"#include \"c.h\"\n"
"// comment\n"
"#include \"b.h\"\n",
sort("#include \"c.h\"\n"
"#include \"a.h\"\n"
"// comment\n"
"#include \"b.h\"\n"));
}
clang-format: Add initial #include sorting capabilities. To implement this nicely, add a function that merges two sets of replacements that are meant to be done in sequence. This functionality will also be useful for other applications, e.g. formatting the result of clang-tidy fixes. llvm-svn: 248367
2015-09-23 16:30:47 +08:00
TEST_F(SortIncludesTest, HandlesAngledIncludesAsSeparateBlocks) {
clang-format: Extend #include sorting functionality Recognize the main module header as well as different #include categories. This should now mimic the behavior of llvm/utils/sort_includes.py as well as clang-tools-extra/clang-tidy/llvm/IncludeOrderCheck.cpp very closely. llvm-svn: 248782
2015-09-29 15:53:08 +08:00
EXPECT_EQ("#include \"a.h\"\n"
"#include \"c.h\"\n"
[clang-format] Regroup #includes into blocks for Google style Summary: Regrouping #includes in blocks separated by blank lines when sorting C++ #include headers was implemented recently, and it has been preferred in Google's C++ style guide: https://google.github.io/styleguide/cppguide.html#Names_and_Order_of_Includes Reviewers: sammccall, klimek Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D60116 llvm-svn: 357567
2019-04-03 17:25:16 +08:00
"#include <array>\n"
clang-format: Extend #include sorting functionality Recognize the main module header as well as different #include categories. This should now mimic the behavior of llvm/utils/sort_includes.py as well as clang-tools-extra/clang-tidy/llvm/IncludeOrderCheck.cpp very closely. llvm-svn: 248782
2015-09-29 15:53:08 +08:00
"#include <b.h>\n"
[clang-format] Regroup #includes into blocks for Google style Summary: Regrouping #includes in blocks separated by blank lines when sorting C++ #include headers was implemented recently, and it has been preferred in Google's C++ style guide: https://google.github.io/styleguide/cppguide.html#Names_and_Order_of_Includes Reviewers: sammccall, klimek Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D60116 llvm-svn: 357567
2019-04-03 17:25:16 +08:00
"#include <d.h>\n"
"#include <vector>\n",
sort("#include <vector>\n"
"#include <d.h>\n"
"#include <array>\n"
clang-format: Extend #include sorting functionality Recognize the main module header as well as different #include categories. This should now mimic the behavior of llvm/utils/sort_includes.py as well as clang-tools-extra/clang-tidy/llvm/IncludeOrderCheck.cpp very closely. llvm-svn: 248782
2015-09-29 15:53:08 +08:00
"#include <b.h>\n"
"#include \"c.h\"\n"
"#include \"a.h\"\n"));
[clang-format] Move #include related style to libToolingCore Summary: This will be shared by include insertion/deletion library. Reviewers: ilya-biryukov Reviewed By: ilya-biryukov Subscribers: mgorny, klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D46758 llvm-svn: 332284
2018-05-15 03:51:33 +08:00
FmtStyle = getGoogleStyle(FormatStyle::LK_Cpp);
clang-format: Add initial #include sorting capabilities. To implement this nicely, add a function that merges two sets of replacements that are meant to be done in sequence. This functionality will also be useful for other applications, e.g. formatting the result of clang-tidy fixes. llvm-svn: 248367
2015-09-23 16:30:47 +08:00
EXPECT_EQ("#include <b.h>\n"
"#include <d.h>\n"
[clang-format] Regroup #includes into blocks for Google style Summary: Regrouping #includes in blocks separated by blank lines when sorting C++ #include headers was implemented recently, and it has been preferred in Google's C++ style guide: https://google.github.io/styleguide/cppguide.html#Names_and_Order_of_Includes Reviewers: sammccall, klimek Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D60116 llvm-svn: 357567
2019-04-03 17:25:16 +08:00
"\n"
"#include <array>\n"
"#include <vector>\n"
"\n"
clang-format: Add initial #include sorting capabilities. To implement this nicely, add a function that merges two sets of replacements that are meant to be done in sequence. This functionality will also be useful for other applications, e.g. formatting the result of clang-tidy fixes. llvm-svn: 248367
2015-09-23 16:30:47 +08:00
"#include \"a.h\"\n"
"#include \"c.h\"\n",
[clang-format] Regroup #includes into blocks for Google style Summary: Regrouping #includes in blocks separated by blank lines when sorting C++ #include headers was implemented recently, and it has been preferred in Google's C++ style guide: https://google.github.io/styleguide/cppguide.html#Names_and_Order_of_Includes Reviewers: sammccall, klimek Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D60116 llvm-svn: 357567
2019-04-03 17:25:16 +08:00
sort("#include <vector>\n"
"#include <d.h>\n"
"#include <array>\n"
clang-format: Add initial #include sorting capabilities. To implement this nicely, add a function that merges two sets of replacements that are meant to be done in sequence. This functionality will also be useful for other applications, e.g. formatting the result of clang-tidy fixes. llvm-svn: 248367
2015-09-23 16:30:47 +08:00
"#include <b.h>\n"
"#include \"c.h\"\n"
"#include \"a.h\"\n"));
}
[clang-format] Add option to group multiple #include blocks when sorting includes Summary: This patch allows grouping multiple #include blocks together and sort all includes as one big block. Additionally, sorted includes can be regrouped after sorting based on configured categories. Contributed by @KrzysztofKapusta! Reviewers: krasimir Reviewed By: krasimir Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D40288 llvm-svn: 319024
2017-11-27 21:23:45 +08:00
TEST_F(SortIncludesTest, RegroupsAngledIncludesInSeparateBlocks) {
[clang-format] Move #include related style to libToolingCore Summary: This will be shared by include insertion/deletion library. Reviewers: ilya-biryukov Reviewed By: ilya-biryukov Subscribers: mgorny, klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D46758 llvm-svn: 332284
2018-05-15 03:51:33 +08:00
Style.IncludeBlocks = tooling::IncludeStyle::IBS_Regroup;
[clang-format] Add option to group multiple #include blocks when sorting includes Summary: This patch allows grouping multiple #include blocks together and sort all includes as one big block. Additionally, sorted includes can be regrouped after sorting based on configured categories. Contributed by @KrzysztofKapusta! Reviewers: krasimir Reviewed By: krasimir Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D40288 llvm-svn: 319024
2017-11-27 21:23:45 +08:00
EXPECT_EQ("#include \"a.h\"\n"
"#include \"c.h\"\n"
"\n"
"#include <b.h>\n"
"#include <d.h>\n",
sort("#include <d.h>\n"
"#include <b.h>\n"
"#include \"c.h\"\n"
"#include \"a.h\"\n"));
}
clang-format: Add initial #include sorting capabilities. To implement this nicely, add a function that merges two sets of replacements that are meant to be done in sequence. This functionality will also be useful for other applications, e.g. formatting the result of clang-tidy fixes. llvm-svn: 248367
2015-09-23 16:30:47 +08:00
TEST_F(SortIncludesTest, HandlesMultilineIncludes) {
EXPECT_EQ("#include \"a.h\"\n"
"#include \"b.h\"\n"
"#include \"c.h\"\n",
sort("#include \"a.h\"\n"
"#include \\\n"
"\"c.h\"\n"
"#include \"b.h\"\n"));
}
clang-format: Extend #include sorting functionality Recognize the main module header as well as different #include categories. This should now mimic the behavior of llvm/utils/sort_includes.py as well as clang-tools-extra/clang-tidy/llvm/IncludeOrderCheck.cpp very closely. llvm-svn: 248782
2015-09-29 15:53:08 +08:00
TEST_F(SortIncludesTest, LeavesMainHeaderFirst) {
clang-format: Make include sorting's main include detection configurable. This patch adds a regular expression to configure suffixes of an included file to check whether it is the "main" include of the current file. Previously, clang-format has allowed arbitrary suffixes on the formatted file, which is still the case when no IncludeMainRegex is specified. llvm-svn: 263943
2016-03-21 22:11:27 +08:00
Style.IncludeIsMainRegex = "([-_](test|unittest))?$";
clang-format: Extend #include sorting functionality Recognize the main module header as well as different #include categories. This should now mimic the behavior of llvm/utils/sort_includes.py as well as clang-tools-extra/clang-tidy/llvm/IncludeOrderCheck.cpp very closely. llvm-svn: 248782
2015-09-29 15:53:08 +08:00
EXPECT_EQ("#include \"llvm/a.h\"\n"
"#include \"b.h\"\n"
"#include \"c.h\"\n",
sort("#include \"llvm/a.h\"\n"
"#include \"c.h\"\n"
clang-format: Extend detection of the "main" #include to use the filename Before, the first (non-system) header in a file was considered to be the main include. This is conservative as it makes clang-format change the #include order less often. Instead implement some basic usage of the filename itself. With this patch, clang-format considers every header to be a main include if the header file's basename is a prefix to the filename the #include is in. llvm-svn: 256148
2015-12-21 20:14:17 +08:00
"#include \"b.h\"\n",
"a.cc"));
clang-format: Extend main header include sorting heuristic to Objective-C files. llvm-svn: 250675
2015-10-19 09:36:09 +08:00
EXPECT_EQ("#include \"llvm/a.h\"\n"
"#include \"b.h\"\n"
"#include \"c.h\"\n",
sort("#include \"llvm/a.h\"\n"
clang-format: Extend detection of the "main" #include to use the filename Before, the first (non-system) header in a file was considered to be the main include. This is conservative as it makes clang-format change the #include order less often. Instead implement some basic usage of the filename itself. With this patch, clang-format considers every header to be a main include if the header file's basename is a prefix to the filename the #include is in. llvm-svn: 256148
2015-12-21 20:14:17 +08:00
"#include \"c.h\"\n"
"#include \"b.h\"\n",
clang-format: Make include sorting's main include detection configurable. This patch adds a regular expression to configure suffixes of an included file to check whether it is the "main" include of the current file. Previously, clang-format has allowed arbitrary suffixes on the formatted file, which is still the case when no IncludeMainRegex is specified. llvm-svn: 263943
2016-03-21 22:11:27 +08:00
"a_test.cc"));
clang-format: Extend detection of the "main" #include to use the filename Before, the first (non-system) header in a file was considered to be the main include. This is conservative as it makes clang-format change the #include order less often. Instead implement some basic usage of the filename itself. With this patch, clang-format considers every header to be a main include if the header file's basename is a prefix to the filename the #include is in. llvm-svn: 256148
2015-12-21 20:14:17 +08:00
EXPECT_EQ("#include \"llvm/input.h\"\n"
"#include \"b.h\"\n"
"#include \"c.h\"\n",
sort("#include \"llvm/input.h\"\n"
clang-format: Extend main header include sorting heuristic to Objective-C files. llvm-svn: 250675
2015-10-19 09:36:09 +08:00
"#include \"c.h\"\n"
"#include \"b.h\"\n",
"input.mm"));
clang-format: Extend #include sorting functionality Recognize the main module header as well as different #include categories. This should now mimic the behavior of llvm/utils/sort_includes.py as well as clang-tools-extra/clang-tidy/llvm/IncludeOrderCheck.cpp very closely. llvm-svn: 248782
2015-09-29 15:53:08 +08:00
clang-format: Make include sorting's main include detection configurable. This patch adds a regular expression to configure suffixes of an included file to check whether it is the "main" include of the current file. Previously, clang-format has allowed arbitrary suffixes on the formatted file, which is still the case when no IncludeMainRegex is specified. llvm-svn: 263943
2016-03-21 22:11:27 +08:00
// Don't allow prefixes.
EXPECT_EQ("#include \"b.h\"\n"
"#include \"c.h\"\n"
"#include \"llvm/not_a.h\"\n",
sort("#include \"llvm/not_a.h\"\n"
"#include \"c.h\"\n"
"#include \"b.h\"\n",
"a.cc"));
// Don't do this for _main and other suffixes.
EXPECT_EQ("#include \"b.h\"\n"
"#include \"c.h\"\n"
"#include \"llvm/a.h\"\n",
sort("#include \"llvm/a.h\"\n"
"#include \"c.h\"\n"
"#include \"b.h\"\n",
"a_main.cc"));
clang-format: Extend #include sorting functionality Recognize the main module header as well as different #include categories. This should now mimic the behavior of llvm/utils/sort_includes.py as well as clang-tools-extra/clang-tidy/llvm/IncludeOrderCheck.cpp very closely. llvm-svn: 248782
2015-09-29 15:53:08 +08:00
// Don't do this in headers.
EXPECT_EQ("#include \"b.h\"\n"
"#include \"c.h\"\n"
"#include \"llvm/a.h\"\n",
sort("#include \"llvm/a.h\"\n"
"#include \"c.h\"\n"
"#include \"b.h\"\n",
clang-format: Extend detection of the "main" #include to use the filename Before, the first (non-system) header in a file was considered to be the main include. This is conservative as it makes clang-format change the #include order less often. Instead implement some basic usage of the filename itself. With this patch, clang-format considers every header to be a main include if the header file's basename is a prefix to the filename the #include is in. llvm-svn: 256148
2015-12-21 20:14:17 +08:00
"a.h"));
clang-format: Only try to find the "main" include in the first block of includes. llvm-svn: 256153
2015-12-21 21:40:49 +08:00
// Only do this in the first #include block.
EXPECT_EQ("#include <a>\n"
"\n"
"#include \"b.h\"\n"
"#include \"c.h\"\n"
"#include \"llvm/a.h\"\n",
sort("#include <a>\n"
"\n"
"#include \"llvm/a.h\"\n"
"#include \"c.h\"\n"
"#include \"b.h\"\n",
"a.cc"));
clang-format: Only consider the first #include that looks right to be the main #include. llvm-svn: 256170
2015-12-22 01:28:24 +08:00
// Only recognize the first #include with a matching basename as main include.
EXPECT_EQ("#include \"a.h\"\n"
"#include \"b.h\"\n"
"#include \"c.h\"\n"
"#include \"llvm/a.h\"\n",
sort("#include \"b.h\"\n"
"#include \"a.h\"\n"
"#include \"c.h\"\n"
"#include \"llvm/a.h\"\n",
"a.cc"));
clang-format: Extend #include sorting functionality Recognize the main module header as well as different #include categories. This should now mimic the behavior of llvm/utils/sort_includes.py as well as clang-tools-extra/clang-tidy/llvm/IncludeOrderCheck.cpp very closely. llvm-svn: 248782
2015-09-29 15:53:08 +08:00
}
[clang-format] Switch to case-insensitive header matching and use it to improve support for LLVM-style include sorting. This really is a collection of improvements to the rules for LLVM include sorting: - We have gmock headers now, so it adds support for those to one of the categories. - LLVM does use 'FooTest.cpp' files to test 'Foo.h' so it adds that suffix for finding a main header. - At times the test file's case may not match the header file's case, so switch to case-insensitive regex matching of header names. With this set of changes, I can't spot any misbehaviors when re-sorting all of LLVM's unittest '#include' lines. Thanks to Eric and Daniel for help testing and refining the patch during review! Differential Revision: https://reviews.llvm.org/D33932 llvm-svn: 306759
2017-06-30 07:20:54 +08:00
[clang-format] Add option to group multiple #include blocks when sorting includes Summary: This patch allows grouping multiple #include blocks together and sort all includes as one big block. Additionally, sorted includes can be regrouped after sorting based on configured categories. Contributed by @KrzysztofKapusta! Reviewers: krasimir Reviewed By: krasimir Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D40288 llvm-svn: 319024
2017-11-27 21:23:45 +08:00
TEST_F(SortIncludesTest, RecognizeMainHeaderInAllGroups) {
Style.IncludeIsMainRegex = "([-_](test|unittest))?$";
[clang-format] Move #include related style to libToolingCore Summary: This will be shared by include insertion/deletion library. Reviewers: ilya-biryukov Reviewed By: ilya-biryukov Subscribers: mgorny, klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D46758 llvm-svn: 332284
2018-05-15 03:51:33 +08:00
Style.IncludeBlocks = tooling::IncludeStyle::IBS_Merge;
[clang-format] Add option to group multiple #include blocks when sorting includes Summary: This patch allows grouping multiple #include blocks together and sort all includes as one big block. Additionally, sorted includes can be regrouped after sorting based on configured categories. Contributed by @KrzysztofKapusta! Reviewers: krasimir Reviewed By: krasimir Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D40288 llvm-svn: 319024
2017-11-27 21:23:45 +08:00
EXPECT_EQ("#include \"c.h\"\n"
"#include \"a.h\"\n"
"#include \"b.h\"\n",
sort("#include \"b.h\"\n"
"\n"
"#include \"a.h\"\n"
"#include \"c.h\"\n",
"c.cc"));
}
TEST_F(SortIncludesTest, MainHeaderIsSeparatedWhenRegroupping) {
Style.IncludeIsMainRegex = "([-_](test|unittest))?$";
[clang-format] Move #include related style to libToolingCore Summary: This will be shared by include insertion/deletion library. Reviewers: ilya-biryukov Reviewed By: ilya-biryukov Subscribers: mgorny, klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D46758 llvm-svn: 332284
2018-05-15 03:51:33 +08:00
Style.IncludeBlocks = tooling::IncludeStyle::IBS_Regroup;
[clang-format] Add option to group multiple #include blocks when sorting includes Summary: This patch allows grouping multiple #include blocks together and sort all includes as one big block. Additionally, sorted includes can be regrouped after sorting based on configured categories. Contributed by @KrzysztofKapusta! Reviewers: krasimir Reviewed By: krasimir Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D40288 llvm-svn: 319024
2017-11-27 21:23:45 +08:00
EXPECT_EQ("#include \"a.h\"\n"
"\n"
"#include \"b.h\"\n"
"#include \"c.h\"\n",
sort("#include \"b.h\"\n"
"\n"
"#include \"a.h\"\n"
"#include \"c.h\"\n",
"a.cc"));
}
[clang-format] Switch to case-insensitive header matching and use it to improve support for LLVM-style include sorting. This really is a collection of improvements to the rules for LLVM include sorting: - We have gmock headers now, so it adds support for those to one of the categories. - LLVM does use 'FooTest.cpp' files to test 'Foo.h' so it adds that suffix for finding a main header. - At times the test file's case may not match the header file's case, so switch to case-insensitive regex matching of header names. With this set of changes, I can't spot any misbehaviors when re-sorting all of LLVM's unittest '#include' lines. Thanks to Eric and Daniel for help testing and refining the patch during review! Differential Revision: https://reviews.llvm.org/D33932 llvm-svn: 306759
2017-06-30 07:20:54 +08:00
TEST_F(SortIncludesTest, SupportCaseInsensitiveMatching) {
// Setup an regex for main includes so we can cover those as well.
Style.IncludeIsMainRegex = "([-_](test|unittest))?$";
// Ensure both main header detection and grouping work in a case insensitive
// manner.
EXPECT_EQ("#include \"llvm/A.h\"\n"
"#include \"b.h\"\n"
"#include \"c.h\"\n"
"#include \"LLVM/z.h\"\n"
"#include \"llvm/X.h\"\n"
"#include \"GTest/GTest.h\"\n"
"#include \"gmock/gmock.h\"\n",
sort("#include \"c.h\"\n"
"#include \"b.h\"\n"
"#include \"GTest/GTest.h\"\n"
"#include \"llvm/A.h\"\n"
"#include \"gmock/gmock.h\"\n"
"#include \"llvm/X.h\"\n"
"#include \"LLVM/z.h\"\n",
"a_TEST.cc"));
}
clang-format: Extend #include sorting functionality Recognize the main module header as well as different #include categories. This should now mimic the behavior of llvm/utils/sort_includes.py as well as clang-tools-extra/clang-tidy/llvm/IncludeOrderCheck.cpp very closely. llvm-svn: 248782
2015-09-29 15:53:08 +08:00
clang-format: Extend header sort category implementation. Specifically, it is sometimes necessary to keep certain #includes as the first #include, even before the main #include for a .cc file. Switching the category to be signed instead of unsigned isn't ideal, but it seems as good of an option as any and is fully backwards compatible. llvm-svn: 255757
2015-12-16 18:10:16 +08:00
TEST_F(SortIncludesTest, NegativePriorities) {
[SortIncludesTest] Add SortPriority fields to fix -Wmissing-field-initializers after D64695/r372919 llvm-svn: 372944
2019-09-26 14:49:37 +08:00
Style.IncludeCategories = {{".*important_os_header.*", -1, 0}, {".*", 1, 0}};
clang-format: Extend header sort category implementation. Specifically, it is sometimes necessary to keep certain #includes as the first #include, even before the main #include for a .cc file. Switching the category to be signed instead of unsigned isn't ideal, but it seems as good of an option as any and is fully backwards compatible. llvm-svn: 255757
2015-12-16 18:10:16 +08:00
EXPECT_EQ("#include \"important_os_header.h\"\n"
clang-format: Extend detection of the "main" #include to use the filename Before, the first (non-system) header in a file was considered to be the main include. This is conservative as it makes clang-format change the #include order less often. Instead implement some basic usage of the filename itself. With this patch, clang-format considers every header to be a main include if the header file's basename is a prefix to the filename the #include is in. llvm-svn: 256148
2015-12-21 20:14:17 +08:00
"#include \"c_main.h\"\n"
"#include \"a_other.h\"\n",
sort("#include \"c_main.h\"\n"
"#include \"a_other.h\"\n"
"#include \"important_os_header.h\"\n",
"c_main.cc"));
// check stable when re-run
EXPECT_EQ("#include \"important_os_header.h\"\n"
"#include \"c_main.h\"\n"
"#include \"a_other.h\"\n",
sort("#include \"important_os_header.h\"\n"
"#include \"c_main.h\"\n"
"#include \"a_other.h\"\n",
[clang-format] Do not emit replacements while regrouping if Cpp includes are OK Summary: Currently clang-format would always emit a replacement for multi-block #include sections if `IBS_Regroup`, even if the sections are correct: ``` % cat ~/test.h #include <a.h> #include "b.h" % bin/clang-format --output-replacements-xml -style=google ~/test.h <?xml version='1.0'?> <replacements xml:space='preserve' incomplete_format='false'> <replacement offset='0' length='30'>#include &lt;a.h>&#10;&#10;#include "b.h"</replacement> </replacements> % ``` This change makes clang-format not emit replacements in this case. The logic is similar to the one implemented for Java in r354452. Reviewers: ioeric Reviewed By: ioeric Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D60199 llvm-svn: 357599
2019-04-03 23:16:04 +08:00
"c_main.cc", 0));
clang-format: Extend header sort category implementation. Specifically, it is sometimes necessary to keep certain #includes as the first #include, even before the main #include for a .cc file. Switching the category to be signed instead of unsigned isn't ideal, but it seems as good of an option as any and is fully backwards compatible. llvm-svn: 255757
2015-12-16 18:10:16 +08:00
}
[clang-format] Add option to group multiple #include blocks when sorting includes Summary: This patch allows grouping multiple #include blocks together and sort all includes as one big block. Additionally, sorted includes can be regrouped after sorting based on configured categories. Contributed by @KrzysztofKapusta! Reviewers: krasimir Reviewed By: krasimir Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D40288 llvm-svn: 319024
2017-11-27 21:23:45 +08:00
TEST_F(SortIncludesTest, PriorityGroupsAreSeparatedWhenRegroupping) {
[SortIncludesTest] Add SortPriority fields to fix -Wmissing-field-initializers after D64695/r372919 llvm-svn: 372944
2019-09-26 14:49:37 +08:00
Style.IncludeCategories = {{".*important_os_header.*", -1, 0}, {".*", 1, 0}};
[clang-format] Move #include related style to libToolingCore Summary: This will be shared by include insertion/deletion library. Reviewers: ilya-biryukov Reviewed By: ilya-biryukov Subscribers: mgorny, klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D46758 llvm-svn: 332284
2018-05-15 03:51:33 +08:00
Style.IncludeBlocks = tooling::IncludeStyle::IBS_Regroup;
[clang-format] Add option to group multiple #include blocks when sorting includes Summary: This patch allows grouping multiple #include blocks together and sort all includes as one big block. Additionally, sorted includes can be regrouped after sorting based on configured categories. Contributed by @KrzysztofKapusta! Reviewers: krasimir Reviewed By: krasimir Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D40288 llvm-svn: 319024
2017-11-27 21:23:45 +08:00
EXPECT_EQ("#include \"important_os_header.h\"\n"
"\n"
"#include \"c_main.h\"\n"
"\n"
"#include \"a_other.h\"\n",
sort("#include \"c_main.h\"\n"
"#include \"a_other.h\"\n"
"#include \"important_os_header.h\"\n",
"c_main.cc"));
// check stable when re-run
EXPECT_EQ("#include \"important_os_header.h\"\n"
"\n"
"#include \"c_main.h\"\n"
"\n"
"#include \"a_other.h\"\n",
sort("#include \"important_os_header.h\"\n"
"\n"
"#include \"c_main.h\"\n"
"\n"
"#include \"a_other.h\"\n",
[clang-format] Do not emit replacements while regrouping if Cpp includes are OK Summary: Currently clang-format would always emit a replacement for multi-block #include sections if `IBS_Regroup`, even if the sections are correct: ``` % cat ~/test.h #include <a.h> #include "b.h" % bin/clang-format --output-replacements-xml -style=google ~/test.h <?xml version='1.0'?> <replacements xml:space='preserve' incomplete_format='false'> <replacement offset='0' length='30'>#include &lt;a.h>&#10;&#10;#include "b.h"</replacement> </replacements> % ``` This change makes clang-format not emit replacements in this case. The logic is similar to the one implemented for Java in r354452. Reviewers: ioeric Reviewed By: ioeric Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D60199 llvm-svn: 357599
2019-04-03 23:16:04 +08:00
"c_main.cc", 0));
[clang-format] Add option to group multiple #include blocks when sorting includes Summary: This patch allows grouping multiple #include blocks together and sort all includes as one big block. Additionally, sorted includes can be regrouped after sorting based on configured categories. Contributed by @KrzysztofKapusta! Reviewers: krasimir Reviewed By: krasimir Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D40288 llvm-svn: 319024
2017-11-27 21:23:45 +08:00
}
clang-format: Make moving of the Cursor work properly when sorting #includes. llvm-svn: 253860
2015-11-23 16:36:35 +08:00
TEST_F(SortIncludesTest, CalculatesCorrectCursorPosition) {
std::string Code = "#include <ccc>\n" // Start of line: 0
"#include <bbbbbb>\n" // Start of line: 15
"#include <a>\n"; // Start of line: 33
EXPECT_EQ(31u, newCursor(Code, 0));
EXPECT_EQ(13u, newCursor(Code, 15));
EXPECT_EQ(0u, newCursor(Code, 33));
EXPECT_EQ(41u, newCursor(Code, 10));
EXPECT_EQ(23u, newCursor(Code, 25));
EXPECT_EQ(10u, newCursor(Code, 43));
}
Make clang-format remove duplicate headers when sorting #includes. Summary: When sorting #includes, #include directives that have the same text will be deduplicated when sorting #includes, and only the first #include in the duplicate #includes remains. If the `Cursor` is provided and put on a deleted #include, it will be put on the remaining #include in the duplicate #includes. Reviewers: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D23274 llvm-svn: 278206
2016-08-10 17:32:23 +08:00
TEST_F(SortIncludesTest, DeduplicateIncludes) {
EXPECT_EQ("#include <a>\n"
"#include <b>\n"
"#include <c>\n",
sort("#include <a>\n"
"#include <b>\n"
"#include <b>\n"
"#include <b>\n"
"#include <b>\n"
"#include <c>\n"));
[clang-format] Add option to group multiple #include blocks when sorting includes Summary: This patch allows grouping multiple #include blocks together and sort all includes as one big block. Additionally, sorted includes can be regrouped after sorting based on configured categories. Contributed by @KrzysztofKapusta! Reviewers: krasimir Reviewed By: krasimir Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D40288 llvm-svn: 319024
2017-11-27 21:23:45 +08:00
[clang-format] Move #include related style to libToolingCore Summary: This will be shared by include insertion/deletion library. Reviewers: ilya-biryukov Reviewed By: ilya-biryukov Subscribers: mgorny, klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D46758 llvm-svn: 332284
2018-05-15 03:51:33 +08:00
Style.IncludeBlocks = tooling::IncludeStyle::IBS_Merge;
[clang-format] Add option to group multiple #include blocks when sorting includes Summary: This patch allows grouping multiple #include blocks together and sort all includes as one big block. Additionally, sorted includes can be regrouped after sorting based on configured categories. Contributed by @KrzysztofKapusta! Reviewers: krasimir Reviewed By: krasimir Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D40288 llvm-svn: 319024
2017-11-27 21:23:45 +08:00
EXPECT_EQ("#include <a>\n"
"#include <b>\n"
"#include <c>\n",
sort("#include <a>\n"
"#include <b>\n"
"\n"
"#include <b>\n"
"\n"
"#include <b>\n"
"#include <c>\n"));
[clang-format] Move #include related style to libToolingCore Summary: This will be shared by include insertion/deletion library. Reviewers: ilya-biryukov Reviewed By: ilya-biryukov Subscribers: mgorny, klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D46758 llvm-svn: 332284
2018-05-15 03:51:33 +08:00
Style.IncludeBlocks = tooling::IncludeStyle::IBS_Regroup;
[clang-format] Add option to group multiple #include blocks when sorting includes Summary: This patch allows grouping multiple #include blocks together and sort all includes as one big block. Additionally, sorted includes can be regrouped after sorting based on configured categories. Contributed by @KrzysztofKapusta! Reviewers: krasimir Reviewed By: krasimir Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D40288 llvm-svn: 319024
2017-11-27 21:23:45 +08:00
EXPECT_EQ("#include <a>\n"
"#include <b>\n"
"#include <c>\n",
sort("#include <a>\n"
"#include <b>\n"
"\n"
"#include <b>\n"
"\n"
"#include <b>\n"
"#include <c>\n"));
Make clang-format remove duplicate headers when sorting #includes. Summary: When sorting #includes, #include directives that have the same text will be deduplicated when sorting #includes, and only the first #include in the duplicate #includes remains. If the `Cursor` is provided and put on a deleted #include, it will be put on the remaining #include in the duplicate #includes. Reviewers: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D23274 llvm-svn: 278206
2016-08-10 17:32:23 +08:00
}
TEST_F(SortIncludesTest, SortAndDeduplicateIncludes) {
EXPECT_EQ("#include <a>\n"
"#include <b>\n"
"#include <c>\n",
sort("#include <b>\n"
"#include <a>\n"
"#include <b>\n"
"#include <b>\n"
"#include <c>\n"
"#include <b>\n"));
[clang-format] Add option to group multiple #include blocks when sorting includes Summary: This patch allows grouping multiple #include blocks together and sort all includes as one big block. Additionally, sorted includes can be regrouped after sorting based on configured categories. Contributed by @KrzysztofKapusta! Reviewers: krasimir Reviewed By: krasimir Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D40288 llvm-svn: 319024
2017-11-27 21:23:45 +08:00
[clang-format] Move #include related style to libToolingCore Summary: This will be shared by include insertion/deletion library. Reviewers: ilya-biryukov Reviewed By: ilya-biryukov Subscribers: mgorny, klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D46758 llvm-svn: 332284
2018-05-15 03:51:33 +08:00
Style.IncludeBlocks = tooling::IncludeStyle::IBS_Merge;
[clang-format] Add option to group multiple #include blocks when sorting includes Summary: This patch allows grouping multiple #include blocks together and sort all includes as one big block. Additionally, sorted includes can be regrouped after sorting based on configured categories. Contributed by @KrzysztofKapusta! Reviewers: krasimir Reviewed By: krasimir Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D40288 llvm-svn: 319024
2017-11-27 21:23:45 +08:00
EXPECT_EQ("#include <a>\n"
"#include <b>\n"
"#include <c>\n",
sort("#include <b>\n"
"#include <a>\n"
"\n"
"#include <b>\n"
"\n"
"#include <c>\n"
"#include <b>\n"));
[clang-format] Move #include related style to libToolingCore Summary: This will be shared by include insertion/deletion library. Reviewers: ilya-biryukov Reviewed By: ilya-biryukov Subscribers: mgorny, klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D46758 llvm-svn: 332284
2018-05-15 03:51:33 +08:00
Style.IncludeBlocks = tooling::IncludeStyle::IBS_Regroup;
[clang-format] Add option to group multiple #include blocks when sorting includes Summary: This patch allows grouping multiple #include blocks together and sort all includes as one big block. Additionally, sorted includes can be regrouped after sorting based on configured categories. Contributed by @KrzysztofKapusta! Reviewers: krasimir Reviewed By: krasimir Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D40288 llvm-svn: 319024
2017-11-27 21:23:45 +08:00
EXPECT_EQ("#include <a>\n"
"#include <b>\n"
"#include <c>\n",
sort("#include <b>\n"
"#include <a>\n"
"\n"
"#include <b>\n"
"\n"
"#include <c>\n"
"#include <b>\n"));
Make clang-format remove duplicate headers when sorting #includes. Summary: When sorting #includes, #include directives that have the same text will be deduplicated when sorting #includes, and only the first #include in the duplicate #includes remains. If the `Cursor` is provided and put on a deleted #include, it will be put on the remaining #include in the duplicate #includes. Reviewers: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D23274 llvm-svn: 278206
2016-08-10 17:32:23 +08:00
}
TEST_F(SortIncludesTest, CalculatesCorrectCursorPositionAfterDeduplicate) {
std::string Code = "#include <b>\n" // Start of line: 0
"#include <a>\n" // Start of line: 13
"#include <b>\n" // Start of line: 26
"#include <b>\n" // Start of line: 39
"#include <c>\n" // Start of line: 52
"#include <b>\n"; // Start of line: 65
std::string Expected = "#include <a>\n" // Start of line: 0
"#include <b>\n" // Start of line: 13
"#include <c>\n"; // Start of line: 26
EXPECT_EQ(Expected, sort(Code));
// Cursor on 'i' in "#include <a>".
EXPECT_EQ(1u, newCursor(Code, 14));
// Cursor on 'b' in "#include <b>".
EXPECT_EQ(23u, newCursor(Code, 10));
EXPECT_EQ(23u, newCursor(Code, 36));
EXPECT_EQ(23u, newCursor(Code, 49));
EXPECT_EQ(23u, newCursor(Code, 36));
EXPECT_EQ(23u, newCursor(Code, 75));
// Cursor on '#' in "#include <c>".
EXPECT_EQ(26u, newCursor(Code, 52));
}
TEST_F(SortIncludesTest, DeduplicateLocallyInEachBlock) {
EXPECT_EQ("#include <a>\n"
"#include <b>\n"
"\n"
"#include <b>\n"
"#include <c>\n",
sort("#include <a>\n"
"#include <b>\n"
"\n"
"#include <c>\n"
"#include <b>\n"
"#include <b>\n"));
}
TEST_F(SortIncludesTest, ValidAffactedRangesAfterDeduplicatingIncludes) {
std::string Code = "#include <a>\n"
"#include <b>\n"
"#include <a>\n"
"#include <a>\n"
"\n"
" int x ;";
std::vector<tooling::Range> Ranges = {tooling::Range(0, 52)};
[clang-format] Move #include related style to libToolingCore Summary: This will be shared by include insertion/deletion library. Reviewers: ilya-biryukov Reviewed By: ilya-biryukov Subscribers: mgorny, klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D46758 llvm-svn: 332284
2018-05-15 03:51:33 +08:00
auto Replaces = sortIncludes(FmtStyle, Code, Ranges, "input.cpp");
Make clang-format remove duplicate headers when sorting #includes. Summary: When sorting #includes, #include directives that have the same text will be deduplicated when sorting #includes, and only the first #include in the duplicate #includes remains. If the `Cursor` is provided and put on a deleted #include, it will be put on the remaining #include in the duplicate #includes. Reviewers: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D23274 llvm-svn: 278206
2016-08-10 17:32:23 +08:00
Ranges = tooling::calculateRangesAfterReplacements(Replaces, Ranges);
EXPECT_EQ(1u, Ranges.size());
EXPECT_EQ(0u, Ranges[0].getOffset());
EXPECT_EQ(26u, Ranges[0].getLength());
}
[clang-format] Do not format likely xml Summary: This patch detects the leading '<' in likely xml files and stops formatting in that case. A recent use of a Qt xml file with a .ts extension triggered this: http://doc.qt.io/qt-4.8/linguist-ts-file-format.html Reviewers: djasper Reviewed By: djasper Subscribers: sammccall, cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D37136 llvm-svn: 311999
2017-08-29 21:51:38 +08:00
TEST_F(SortIncludesTest, DoNotSortLikelyXml) {
EXPECT_EQ("<!--;\n"
"#include <b>\n"
"#include <a>\n"
"-->",
sort("<!--;\n"
"#include <b>\n"
"#include <a>\n"
[clang-format] Do not emit replacements while regrouping if Cpp includes are OK Summary: Currently clang-format would always emit a replacement for multi-block #include sections if `IBS_Regroup`, even if the sections are correct: ``` % cat ~/test.h #include <a.h> #include "b.h" % bin/clang-format --output-replacements-xml -style=google ~/test.h <?xml version='1.0'?> <replacements xml:space='preserve' incomplete_format='false'> <replacement offset='0' length='30'>#include &lt;a.h>&#10;&#10;#include "b.h"</replacement> </replacements> % ``` This change makes clang-format not emit replacements in this case. The logic is similar to the one implemented for Java in r354452. Reviewers: ioeric Reviewed By: ioeric Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D60199 llvm-svn: 357599
2019-04-03 23:16:04 +08:00
"-->", "input.h", 0));
}
TEST_F(SortIncludesTest, DoNotOutputReplacementsForSortedBlocksWithRegrouping) {
Style.IncludeBlocks = Style.IBS_Regroup;
std::string Code = R"(
#include "b.h"
#include <a.h>
)";
EXPECT_EQ(Code, sort(Code, "input.h", 0));
[clang-format] Do not format likely xml Summary: This patch detects the leading '<' in likely xml files and stops formatting in that case. A recent use of a Qt xml file with a .ts extension triggered this: http://doc.qt.io/qt-4.8/linguist-ts-file-format.html Reviewers: djasper Reviewed By: djasper Subscribers: sammccall, cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D37136 llvm-svn: 311999
2017-08-29 21:51:38 +08:00
}
[clang-format] [PR43372] - clang-format shows replacements in DOS files when no replacement is needed Summary: This is a patch to fix PR43372 (https://bugs.llvm.org/show_bug.cgi?id=43372) - clang-format can't format file with includes, ( which really keep providing replacements for already sorted headers.) A similar issue was addressed by @krasimir in {D60199}, however, this seemingly only prevented the issue when the files being formatted did not contain windows line endings (\r\n) It's possible this is related to https://twitter.com/StephanTLavavej/status/1176722938243895296 given who @STL_MSFT works for! As people often used the existence of replacements to determine if a file needs clang-formatting, this is probably pretty important for windows users There may be a better way of comparing 2 strings and ignoring \r (which appear in both Results and Code), I couldn't choose between this idiom or the copy_if approach, but I'm happy to change it to whatever people consider more performant. Reviewers: krasimir, klimek, owenpan, ioeric Reviewed By: krasimir Subscribers: cfe-commits, STL_MSFT, krasimir Tags: #clang-format, #clang, #clang-tools-extra Differential Revision: https://reviews.llvm.org/D68227 llvm-svn: 373388
2019-10-02 04:20:22 +08:00
TEST_F(SortIncludesTest,
DoNotOutputReplacementsForSortedBlocksWithRegroupingWindows) {
Style.IncludeBlocks = Style.IBS_Regroup;
std::string Code = "#include \"b.h\"\r\n"
"\r\n"
"#include <a.h>\r\n";
EXPECT_EQ(Code, sort(Code, "input.h", 0));
}
[clang-format] Preserve include blocks in ObjC Google style Summary: r357567 started to regroup include block for Google style; it was meant to apply only for C++. This patch reverts this for ObjC. Reviewers: ioeric Reviewed By: ioeric Subscribers: thakis, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D60263 llvm-svn: 357695
2019-04-04 22:04:26 +08:00
TEST_F(SortIncludesTest, DoNotRegroupGroupsInGoogleObjCStyle) {
FmtStyle = getGoogleStyle(FormatStyle::LK_ObjC);
EXPECT_EQ("#include <a.h>\n"
"#include <b.h>\n"
"#include \"a.h\"",
sort("#include <b.h>\n"
"#include <a.h>\n"
"#include \"a.h\""));
}
clang-format: Add initial #include sorting capabilities. To implement this nicely, add a function that merges two sets of replacements that are meant to be done in sequence. This functionality will also be useful for other applications, e.g. formatting the result of clang-tidy fixes. llvm-svn: 248367
2015-09-23 16:30:47 +08:00
} // end namespace
} // end namespace format
} // end namespace clang