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/NamespaceEndCommentsFixerTe...

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

1267 lines
47 KiB
C++
Raw Normal View History

[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
//===- NamespaceEndCommentsFixerTest.cpp - Formatting 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 a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
//
//===----------------------------------------------------------------------===//
#include "clang/Format/Format.h"
#include "llvm/Support/Debug.h"
#include "gtest/gtest.h"
#define DEBUG_TYPE "namespace-end-comments-fixer-test"
namespace clang {
namespace format {
namespace {
class NamespaceEndCommentsFixerTest : public ::testing::Test {
protected:
std::string
fixNamespaceEndComments(llvm::StringRef Code,
[clang-format] Clang-tidy cleanup of NamespaceEndCommentFixerTest.cpp, NFC llvm-svn: 300983
2017-04-21 22:30:01 +08:00
const std::vector<tooling::Range> &Ranges,
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
const FormatStyle &Style = getLLVMStyle()) {
[clang] Update uses of DEBUG macro to LLVM_DEBUG. The DEBUG() macro is very generic so it might clash with other projects. The renaming was done as follows: - git grep -l 'DEBUG' | xargs sed -i 's/\bDEBUG\s\?(/LLVM_DEBUG(/g' - git diff -U0 master | ../clang/tools/clang-format/clang-format-diff.py -i -p1 -style LLVM Explicitly avoided changing the strings in the clang-format tests. Differential Revision: https://reviews.llvm.org/D44975 llvm-svn: 332350
2018-05-15 21:30:56 +08:00
LLVM_DEBUG(llvm::errs() << "---\n");
LLVM_DEBUG(llvm::errs() << Code << "\n\n");
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
tooling::Replacements Replaces =
clang::format::fixNamespaceEndComments(Style, Code, Ranges, "<stdin>");
auto Result = applyAllReplacements(Code, Replaces);
EXPECT_TRUE(static_cast<bool>(Result));
[clang] Update uses of DEBUG macro to LLVM_DEBUG. The DEBUG() macro is very generic so it might clash with other projects. The renaming was done as follows: - git grep -l 'DEBUG' | xargs sed -i 's/\bDEBUG\s\?(/LLVM_DEBUG(/g' - git diff -U0 master | ../clang/tools/clang-format/clang-format-diff.py -i -p1 -style LLVM Explicitly avoided changing the strings in the clang-format tests. Differential Revision: https://reviews.llvm.org/D44975 llvm-svn: 332350
2018-05-15 21:30:56 +08:00
LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
return *Result;
}
std::string
fixNamespaceEndComments(llvm::StringRef Code,
const FormatStyle &Style = getLLVMStyle()) {
return fixNamespaceEndComments(
Code,
/*Ranges=*/{1, tooling::Range(0, Code.size())}, Style);
}
};
TEST_F(NamespaceEndCommentsFixerTest, AddsEndComment) {
EXPECT_EQ("namespace {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"int j;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}// namespace",
fixNamespaceEndComments("namespace {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"int j;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}"));
clang-format: better handle namespace macros Summary: Other macros are used to declare namespaces, and should thus be handled similarly. This is the case for crpcut's TESTSUITE macro, or for unittest-cpp's SUITE macro: TESTSUITE(Foo) { TEST(MyFirstTest) { assert(0); } } // TESTSUITE(Foo) This patch deals with this cases by introducing a new option to specify lists of namespace macros. Internally, it re-uses the system already in place for foreach and statement macros, to ensure there is no impact on performance. Reviewers: krasimir, djasper, klimek Reviewed By: klimek Subscribers: acoomans, cfe-commits, klimek Tags: #clang Differential Revision: https://reviews.llvm.org/D37813 llvm-svn: 362740
2019-06-07 04:06:23 +08:00
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
EXPECT_EQ("namespace {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"int j;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}// namespace\n",
fixNamespaceEndComments("namespace {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"int j;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}\n"));
EXPECT_EQ("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"int j;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}// namespace A",
fixNamespaceEndComments("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"int j;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}"));
EXPECT_EQ("inline namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"int j;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}// namespace A",
fixNamespaceEndComments("inline namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"int j;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}"));
clang-format: Fix namespace end comments for namespaces with attributes and macros. Fixes PR39247. While here, also make C++20 `namespace A::inline B::inline C` nested inline namespaced definitions work. Before: #define DEPRECATE_WOOF [[deprecated("meow")]] namespace DEPRECATE_WOOF woof { void f() {} } // namespace DEPRECATE_WOOFwoof namespace [[deprecated("meow")]] woof { void f() {} } // namespace [[deprecated("meow")]]woof namespace woof::inline bark { void f() {} } // namespace woof::inlinebark Now: #define DEPRECATE_WOOF [[deprecated("meow")]] namespace DEPRECATE_WOOF woof { void f() {} } // namespace woof namespace [[deprecated("meow")]] woof { void f() {} } // namespace woof namespace woof::inline bark { void f() {} } // namespace woof::inline bark (In addition to the fixed namespace end comments, also note the correct indent of the namespace contents.) Differential Revision: https://reviews.llvm.org/D65125 llvm-svn: 366831
2019-07-24 01:49:45 +08:00
EXPECT_EQ("namespace [[deprecated(\"foo\")]] A::B {\n"
"int i;\n"
"int j;\n"
"}// namespace A::B",
fixNamespaceEndComments("namespace [[deprecated(\"foo\")]] A::B {\n"
"int i;\n"
"int j;\n"
"}"));
EXPECT_EQ("namespace [[deprecated(\"foo\")]] A::inline B::inline C {\n"
"int i;\n"
"int j;\n"
"}// namespace A::inline B::inline C",
fixNamespaceEndComments(
"namespace [[deprecated(\"foo\")]] A::inline B::inline C {\n"
"int i;\n"
"int j;\n"
"}"));
EXPECT_EQ("namespace DEPRECATED A::B {\n"
"int i;\n"
"int j;\n"
"}// namespace A::B",
fixNamespaceEndComments("namespace DEPRECATED A::B {\n"
"int i;\n"
"int j;\n"
"}"));
EXPECT_EQ("inline namespace [[deprecated]] A {\n"
"int i;\n"
"int j;\n"
"}// namespace A",
fixNamespaceEndComments("inline namespace [[deprecated]] A {\n"
"int i;\n"
"int j;\n"
"}"));
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
EXPECT_EQ("namespace ::A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"int j;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}// namespace ::A",
fixNamespaceEndComments("namespace ::A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"int j;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}"));
EXPECT_EQ("namespace ::A::B {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"int j;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}// namespace ::A::B",
fixNamespaceEndComments("namespace ::A::B {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"int j;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}"));
EXPECT_EQ("namespace /**/::/**/A/**/::/**/B/**/ {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"int j;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}// namespace ::A::B",
fixNamespaceEndComments("namespace /**/::/**/A/**/::/**/B/**/ {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"int j;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}"));
EXPECT_EQ("namespace A {\n"
"namespace B {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Use number of unwrapped lines for short namespace Summary: This patch makes the namespace comment fixer use the number of unwrapped lines that a namespace spans to detect it that namespace is short, thus not needing end comments to be added. This is needed to ensure clang-format is idempotent. Previously, a short namespace was detected by the original source code lines. This has the effect of requiring two runs for this example: ``` namespace { class A; } ``` after first run: ``` namespace { class A; } ``` after second run: ``` namespace { class A; } // namespace ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30528 llvm-svn: 296736
2017-03-02 17:54:44 +08:00
"}\n"
"}// namespace A",
fixNamespaceEndComments("namespace A {\n"
"namespace B {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Use number of unwrapped lines for short namespace Summary: This patch makes the namespace comment fixer use the number of unwrapped lines that a namespace spans to detect it that namespace is short, thus not needing end comments to be added. This is needed to ensure clang-format is idempotent. Previously, a short namespace was detected by the original source code lines. This has the effect of requiring two runs for this example: ``` namespace { class A; } ``` after first run: ``` namespace { class A; } ``` after second run: ``` namespace { class A; } // namespace ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30528 llvm-svn: 296736
2017-03-02 17:54:44 +08:00
"}\n"
"}"));
EXPECT_EQ("namespace A {\n"
"namespace B {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"int j;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}// namespace B\n"
"}// namespace A",
fixNamespaceEndComments("namespace A {\n"
"namespace B {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"int j;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}\n"
"}"));
EXPECT_EQ("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int a;\n"
"int b;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}// namespace A\n"
"namespace B {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int b;\n"
"int a;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}// namespace B",
fixNamespaceEndComments("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int a;\n"
"int b;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}\n"
"namespace B {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int b;\n"
"int a;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}"));
EXPECT_EQ("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int a1;\n"
"int a2;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}// namespace A\n"
"namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int a2;\n"
"int a1;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}// namespace A",
fixNamespaceEndComments("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int a1;\n"
"int a2;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}\n"
"namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int a2;\n"
"int a1;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}"));
EXPECT_EQ("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int a;\n"
"int b;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}// namespace A\n"
"// comment about b\n"
"int b;",
fixNamespaceEndComments("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int a;\n"
"int b;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}\n"
"// comment about b\n"
"int b;"));
EXPECT_EQ("namespace A {\n"
"namespace B {\n"
"namespace C {\n"
"namespace D {\n"
[clang-format] Use number of unwrapped lines for short namespace Summary: This patch makes the namespace comment fixer use the number of unwrapped lines that a namespace spans to detect it that namespace is short, thus not needing end comments to be added. This is needed to ensure clang-format is idempotent. Previously, a short namespace was detected by the original source code lines. This has the effect of requiring two runs for this example: ``` namespace { class A; } ``` after first run: ``` namespace { class A; } ``` after second run: ``` namespace { class A; } // namespace ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30528 llvm-svn: 296736
2017-03-02 17:54:44 +08:00
"}\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}// namespace C\n"
"}// namespace B\n"
"}// namespace A",
fixNamespaceEndComments("namespace A {\n"
"namespace B {\n"
"namespace C {\n"
"namespace D {\n"
"}\n"
"}\n"
"}\n"
"}"));
[clang-format] Support namespaces ending in semicolon Summary: This patch adds support for namespaces ending in semicolon to the namespace comment fixer. source: ``` namespace A { int i; int j; }; ``` clang-format before: ``` namespace A { int i; int j; } // namespace A; ``` clang-format after: ``` namespace A { int i; int j; }; // namespace A ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30688 llvm-svn: 297140
2017-03-07 22:07:43 +08:00
clang-format: Add CompactNamespaces option Summary: Add CompactNamespaces option, to pack namespace declarations on the same line (somewhat similar to C++17 nested namespace definition). With this option, consecutive namespace declarations are kept on the same line: namespace foo { namespace bar { ... }} // namespace foo::bar Reviewers: krasimir, djasper, klimek Reviewed By: djasper Subscribers: kimgr, cfe-commits, klimek Tags: #clang-tools-extra Differential Revision: https://reviews.llvm.org/D32480 llvm-svn: 305384
2017-06-14 20:29:47 +08:00
// Add comment for namespaces which will be 'compacted'
FormatStyle CompactNamespacesStyle = getLLVMStyle();
CompactNamespacesStyle.CompactNamespaces = true;
EXPECT_EQ("namespace out { namespace in {\n"
"int i;\n"
"int j;\n"
"}}// namespace out::in",
fixNamespaceEndComments("namespace out { namespace in {\n"
"int i;\n"
"int j;\n"
"}}",
CompactNamespacesStyle));
EXPECT_EQ("namespace out {\n"
"namespace in {\n"
"int i;\n"
"int j;\n"
"}\n"
"}// namespace out::in",
fixNamespaceEndComments("namespace out {\n"
"namespace in {\n"
"int i;\n"
"int j;\n"
"}\n"
"}",
CompactNamespacesStyle));
EXPECT_EQ("namespace out { namespace in {\n"
"int i;\n"
"int j;\n"
"};}// namespace out::in",
fixNamespaceEndComments("namespace out { namespace in {\n"
"int i;\n"
"int j;\n"
"};}",
CompactNamespacesStyle));
[clang-format] Support namespaces ending in semicolon Summary: This patch adds support for namespaces ending in semicolon to the namespace comment fixer. source: ``` namespace A { int i; int j; }; ``` clang-format before: ``` namespace A { int i; int j; } // namespace A; ``` clang-format after: ``` namespace A { int i; int j; }; // namespace A ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30688 llvm-svn: 297140
2017-03-07 22:07:43 +08:00
// Adds an end comment after a semicolon.
EXPECT_EQ("namespace {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"int j;\n"
[clang-format] Support namespaces ending in semicolon Summary: This patch adds support for namespaces ending in semicolon to the namespace comment fixer. source: ``` namespace A { int i; int j; }; ``` clang-format before: ``` namespace A { int i; int j; } // namespace A; ``` clang-format after: ``` namespace A { int i; int j; }; // namespace A ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30688 llvm-svn: 297140
2017-03-07 22:07:43 +08:00
"};// namespace",
fixNamespaceEndComments("namespace {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"int j;\n"
[clang-format] Support namespaces ending in semicolon Summary: This patch adds support for namespaces ending in semicolon to the namespace comment fixer. source: ``` namespace A { int i; int j; }; ``` clang-format before: ``` namespace A { int i; int j; } // namespace A; ``` clang-format after: ``` namespace A { int i; int j; }; // namespace A ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30688 llvm-svn: 297140
2017-03-07 22:07:43 +08:00
"};"));
EXPECT_EQ("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"int j;\n"
[clang-format] Support namespaces ending in semicolon Summary: This patch adds support for namespaces ending in semicolon to the namespace comment fixer. source: ``` namespace A { int i; int j; }; ``` clang-format before: ``` namespace A { int i; int j; } // namespace A; ``` clang-format after: ``` namespace A { int i; int j; }; // namespace A ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30688 llvm-svn: 297140
2017-03-07 22:07:43 +08:00
"};// namespace A",
fixNamespaceEndComments("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"int j;\n"
[clang-format] Support namespaces ending in semicolon Summary: This patch adds support for namespaces ending in semicolon to the namespace comment fixer. source: ``` namespace A { int i; int j; }; ``` clang-format before: ``` namespace A { int i; int j; } // namespace A; ``` clang-format after: ``` namespace A { int i; int j; }; // namespace A ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30688 llvm-svn: 297140
2017-03-07 22:07:43 +08:00
"};"));
EXPECT_EQ("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"int j;\n"
[clang-format] Support namespaces ending in semicolon Summary: This patch adds support for namespaces ending in semicolon to the namespace comment fixer. source: ``` namespace A { int i; int j; }; ``` clang-format before: ``` namespace A { int i; int j; } // namespace A; ``` clang-format after: ``` namespace A { int i; int j; }; // namespace A ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30688 llvm-svn: 297140
2017-03-07 22:07:43 +08:00
"};// namespace A\n"
"// unrelated",
fixNamespaceEndComments("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"int j;\n"
[clang-format] Support namespaces ending in semicolon Summary: This patch adds support for namespaces ending in semicolon to the namespace comment fixer. source: ``` namespace A { int i; int j; }; ``` clang-format before: ``` namespace A { int i; int j; } // namespace A; ``` clang-format after: ``` namespace A { int i; int j; }; // namespace A ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30688 llvm-svn: 297140
2017-03-07 22:07:43 +08:00
"};\n"
"// unrelated"));
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
}
clang-format: better handle namespace macros Summary: Other macros are used to declare namespaces, and should thus be handled similarly. This is the case for crpcut's TESTSUITE macro, or for unittest-cpp's SUITE macro: TESTSUITE(Foo) { TEST(MyFirstTest) { assert(0); } } // TESTSUITE(Foo) This patch deals with this cases by introducing a new option to specify lists of namespace macros. Internally, it re-uses the system already in place for foreach and statement macros, to ensure there is no impact on performance. Reviewers: krasimir, djasper, klimek Reviewed By: klimek Subscribers: acoomans, cfe-commits, klimek Tags: #clang Differential Revision: https://reviews.llvm.org/D37813 llvm-svn: 362740
2019-06-07 04:06:23 +08:00
TEST_F(NamespaceEndCommentsFixerTest, AddsMacroEndComment) {
FormatStyle Style = getLLVMStyle();
Style.NamespaceMacros.push_back("TESTSUITE");
EXPECT_EQ("TESTSUITE() {\n"
"int i;\n"
"int j;\n"
"}// TESTSUITE()",
fixNamespaceEndComments("TESTSUITE() {\n"
"int i;\n"
"int j;\n"
"}",
Style));
EXPECT_EQ("TESTSUITE(A) {\n"
"int i;\n"
"int j;\n"
"}// TESTSUITE(A)",
fixNamespaceEndComments("TESTSUITE(A) {\n"
"int i;\n"
"int j;\n"
"}",
Style));
EXPECT_EQ("inline TESTSUITE(A) {\n"
"int i;\n"
"int j;\n"
"}// TESTSUITE(A)",
fixNamespaceEndComments("inline TESTSUITE(A) {\n"
"int i;\n"
"int j;\n"
"}",
Style));
EXPECT_EQ("TESTSUITE(::A) {\n"
"int i;\n"
"int j;\n"
"}// TESTSUITE(::A)",
fixNamespaceEndComments("TESTSUITE(::A) {\n"
"int i;\n"
"int j;\n"
"}",
Style));
EXPECT_EQ("TESTSUITE(::A::B) {\n"
"int i;\n"
"int j;\n"
"}// TESTSUITE(::A::B)",
fixNamespaceEndComments("TESTSUITE(::A::B) {\n"
"int i;\n"
"int j;\n"
"}",
Style));
EXPECT_EQ("TESTSUITE(/**/::/**/A/**/::/**/B/**/) {\n"
"int i;\n"
"int j;\n"
"}// TESTSUITE(::A::B)",
fixNamespaceEndComments("TESTSUITE(/**/::/**/A/**/::/**/B/**/) {\n"
"int i;\n"
"int j;\n"
"}",
Style));
EXPECT_EQ("TESTSUITE(A, B) {\n"
"int i;\n"
"int j;\n"
"}// TESTSUITE(A)",
fixNamespaceEndComments("TESTSUITE(A, B) {\n"
"int i;\n"
"int j;\n"
"}",
Style));
EXPECT_EQ("TESTSUITE(\"Test1\") {\n"
"int i;\n"
"int j;\n"
"}// TESTSUITE(\"Test1\")",
fixNamespaceEndComments("TESTSUITE(\"Test1\") {\n"
"int i;\n"
"int j;\n"
"}",
Style));
}
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
TEST_F(NamespaceEndCommentsFixerTest, AddsNewlineIfNeeded) {
EXPECT_EQ("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"int j;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}// namespace A\n"
[clang-format] Use number of unwrapped lines for short namespace Summary: This patch makes the namespace comment fixer use the number of unwrapped lines that a namespace spans to detect it that namespace is short, thus not needing end comments to be added. This is needed to ensure clang-format is idempotent. Previously, a short namespace was detected by the original source code lines. This has the effect of requiring two runs for this example: ``` namespace { class A; } ``` after first run: ``` namespace { class A; } ``` after second run: ``` namespace { class A; } // namespace ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30528 llvm-svn: 296736
2017-03-02 17:54:44 +08:00
" int k;",
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
fixNamespaceEndComments("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"int j;\n"
[clang-format] Use number of unwrapped lines for short namespace Summary: This patch makes the namespace comment fixer use the number of unwrapped lines that a namespace spans to detect it that namespace is short, thus not needing end comments to be added. This is needed to ensure clang-format is idempotent. Previously, a short namespace was detected by the original source code lines. This has the effect of requiring two runs for this example: ``` namespace { class A; } ``` after first run: ``` namespace { class A; } ``` after second run: ``` namespace { class A; } // namespace ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30528 llvm-svn: 296736
2017-03-02 17:54:44 +08:00
"} int k;"));
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
EXPECT_EQ("namespace {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"int j;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}// namespace\n"
[clang-format] Use number of unwrapped lines for short namespace Summary: This patch makes the namespace comment fixer use the number of unwrapped lines that a namespace spans to detect it that namespace is short, thus not needing end comments to be added. This is needed to ensure clang-format is idempotent. Previously, a short namespace was detected by the original source code lines. This has the effect of requiring two runs for this example: ``` namespace { class A; } ``` after first run: ``` namespace { class A; } ``` after second run: ``` namespace { class A; } // namespace ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30528 llvm-svn: 296736
2017-03-02 17:54:44 +08:00
" int k;",
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
fixNamespaceEndComments("namespace {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"int j;\n"
[clang-format] Use number of unwrapped lines for short namespace Summary: This patch makes the namespace comment fixer use the number of unwrapped lines that a namespace spans to detect it that namespace is short, thus not needing end comments to be added. This is needed to ensure clang-format is idempotent. Previously, a short namespace was detected by the original source code lines. This has the effect of requiring two runs for this example: ``` namespace { class A; } ``` after first run: ``` namespace { class A; } ``` after second run: ``` namespace { class A; } // namespace ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30528 llvm-svn: 296736
2017-03-02 17:54:44 +08:00
"} int k;"));
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
EXPECT_EQ("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"int j;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}// namespace A\n"
" namespace B {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int j;\n"
"int k;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}// namespace B",
fixNamespaceEndComments("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"int j;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"} namespace B {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int j;\n"
"int k;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}"));
[clang-format] Support namespaces ending in semicolon Summary: This patch adds support for namespaces ending in semicolon to the namespace comment fixer. source: ``` namespace A { int i; int j; }; ``` clang-format before: ``` namespace A { int i; int j; } // namespace A; ``` clang-format after: ``` namespace A { int i; int j; }; // namespace A ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30688 llvm-svn: 297140
2017-03-07 22:07:43 +08:00
EXPECT_EQ("namespace {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"int j;\n"
[clang-format] Support namespaces ending in semicolon Summary: This patch adds support for namespaces ending in semicolon to the namespace comment fixer. source: ``` namespace A { int i; int j; }; ``` clang-format before: ``` namespace A { int i; int j; } // namespace A; ``` clang-format after: ``` namespace A { int i; int j; }; // namespace A ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30688 llvm-svn: 297140
2017-03-07 22:07:43 +08:00
"};// namespace\n"
"int k;",
fixNamespaceEndComments("namespace {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"int j;\n"
[clang-format] Support namespaces ending in semicolon Summary: This patch adds support for namespaces ending in semicolon to the namespace comment fixer. source: ``` namespace A { int i; int j; }; ``` clang-format before: ``` namespace A { int i; int j; } // namespace A; ``` clang-format after: ``` namespace A { int i; int j; }; // namespace A ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30688 llvm-svn: 297140
2017-03-07 22:07:43 +08:00
"};int k;"));
EXPECT_EQ("namespace {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"int j;\n"
[clang-format] Support namespaces ending in semicolon Summary: This patch adds support for namespaces ending in semicolon to the namespace comment fixer. source: ``` namespace A { int i; int j; }; ``` clang-format before: ``` namespace A { int i; int j; } // namespace A; ``` clang-format after: ``` namespace A { int i; int j; }; // namespace A ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30688 llvm-svn: 297140
2017-03-07 22:07:43 +08:00
"};// namespace\n"
";",
fixNamespaceEndComments("namespace {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"int j;\n"
[clang-format] Support namespaces ending in semicolon Summary: This patch adds support for namespaces ending in semicolon to the namespace comment fixer. source: ``` namespace A { int i; int j; }; ``` clang-format before: ``` namespace A { int i; int j; } // namespace A; ``` clang-format after: ``` namespace A { int i; int j; }; // namespace A ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30688 llvm-svn: 297140
2017-03-07 22:07:43 +08:00
"};;"));
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
}
TEST_F(NamespaceEndCommentsFixerTest, DoesNotAddEndCommentForShortNamespace) {
EXPECT_EQ("namespace {}", fixNamespaceEndComments("namespace {}"));
EXPECT_EQ("namespace A {}", fixNamespaceEndComments("namespace A {}"));
[clang-format] NFC - clang-format the FormatTests Summary: Ensure the clang-format unit tests are themselves clang-formatted Having areas of the llvm code which are clang-format clean, give us more areas to run new clang-format binaries on ensuring we haven't broken anything. It seems to me we SHOULD have this clang-formatted at a minimum, otherwise how can we expect others to use clang-format if we "don't eat our own dogfood", also if the tests are dependent on the formatting of the code then that would also be bad! Reviewed By: sammccall Subscribers: cfe-commits Tags: #clang, #clang-format Differential Revision: https://reviews.llvm.org/D79204
2020-05-02 22:42:20 +08:00
EXPECT_EQ("namespace A { a }", fixNamespaceEndComments("namespace A { a }"));
[clang-format] Support namespaces ending in semicolon Summary: This patch adds support for namespaces ending in semicolon to the namespace comment fixer. source: ``` namespace A { int i; int j; }; ``` clang-format before: ``` namespace A { int i; int j; } // namespace A; ``` clang-format after: ``` namespace A { int i; int j; }; // namespace A ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30688 llvm-svn: 297140
2017-03-07 22:07:43 +08:00
EXPECT_EQ("namespace A { a };",
fixNamespaceEndComments("namespace A { a };"));
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
}
TEST_F(NamespaceEndCommentsFixerTest, DoesNotAddCommentAfterUnaffectedRBrace) {
EXPECT_EQ("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}",
fixNamespaceEndComments("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}",
// The range (16, 3) spans the 'int' above.
/*Ranges=*/{1, tooling::Range(16, 3)}));
[clang-format] Support namespaces ending in semicolon Summary: This patch adds support for namespaces ending in semicolon to the namespace comment fixer. source: ``` namespace A { int i; int j; }; ``` clang-format before: ``` namespace A { int i; int j; } // namespace A; ``` clang-format after: ``` namespace A { int i; int j; }; // namespace A ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30688 llvm-svn: 297140
2017-03-07 22:07:43 +08:00
EXPECT_EQ("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Support namespaces ending in semicolon Summary: This patch adds support for namespaces ending in semicolon to the namespace comment fixer. source: ``` namespace A { int i; int j; }; ``` clang-format before: ``` namespace A { int i; int j; } // namespace A; ``` clang-format after: ``` namespace A { int i; int j; }; // namespace A ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30688 llvm-svn: 297140
2017-03-07 22:07:43 +08:00
"};",
fixNamespaceEndComments("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Support namespaces ending in semicolon Summary: This patch adds support for namespaces ending in semicolon to the namespace comment fixer. source: ``` namespace A { int i; int j; }; ``` clang-format before: ``` namespace A { int i; int j; } // namespace A; ``` clang-format after: ``` namespace A { int i; int j; }; // namespace A ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30688 llvm-svn: 297140
2017-03-07 22:07:43 +08:00
"};",
// The range (16, 3) spans the 'int' above.
/*Ranges=*/{1, tooling::Range(16, 3)}));
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
}
clang-format: Fix namespace end comments for namespaces with attributes and macros. Fixes PR39247. While here, also make C++20 `namespace A::inline B::inline C` nested inline namespaced definitions work. Before: #define DEPRECATE_WOOF [[deprecated("meow")]] namespace DEPRECATE_WOOF woof { void f() {} } // namespace DEPRECATE_WOOFwoof namespace [[deprecated("meow")]] woof { void f() {} } // namespace [[deprecated("meow")]]woof namespace woof::inline bark { void f() {} } // namespace woof::inlinebark Now: #define DEPRECATE_WOOF [[deprecated("meow")]] namespace DEPRECATE_WOOF woof { void f() {} } // namespace woof namespace [[deprecated("meow")]] woof { void f() {} } // namespace woof namespace woof::inline bark { void f() {} } // namespace woof::inline bark (In addition to the fixed namespace end comments, also note the correct indent of the namespace contents.) Differential Revision: https://reviews.llvm.org/D65125 llvm-svn: 366831
2019-07-24 01:49:45 +08:00
TEST_F(NamespaceEndCommentsFixerTest,
DoesNotAddCommentAfterRBraceInPPDirective) {
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
EXPECT_EQ("#define SAD \\\n"
"namespace A { \\\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i; \\\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}",
fixNamespaceEndComments("#define SAD \\\n"
"namespace A { \\\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i; \\\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}"));
}
TEST_F(NamespaceEndCommentsFixerTest, KeepsValidEndComment) {
EXPECT_EQ("namespace {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"} // end anonymous namespace",
fixNamespaceEndComments("namespace {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"} // end anonymous namespace"));
EXPECT_EQ("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"} /* end of namespace A */",
fixNamespaceEndComments("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"} /* end of namespace A */"));
EXPECT_EQ("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"} // namespace A",
fixNamespaceEndComments("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"} // namespace A"));
EXPECT_EQ("namespace A::B {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"} // end namespace A::B",
fixNamespaceEndComments("namespace A::B {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"} // end namespace A::B"));
[clang-format] Support namespaces ending in semicolon Summary: This patch adds support for namespaces ending in semicolon to the namespace comment fixer. source: ``` namespace A { int i; int j; }; ``` clang-format before: ``` namespace A { int i; int j; } // namespace A; ``` clang-format after: ``` namespace A { int i; int j; }; // namespace A ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30688 llvm-svn: 297140
2017-03-07 22:07:43 +08:00
EXPECT_EQ("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Support namespaces ending in semicolon Summary: This patch adds support for namespaces ending in semicolon to the namespace comment fixer. source: ``` namespace A { int i; int j; }; ``` clang-format before: ``` namespace A { int i; int j; } // namespace A; ``` clang-format after: ``` namespace A { int i; int j; }; // namespace A ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30688 llvm-svn: 297140
2017-03-07 22:07:43 +08:00
"}; // end namespace A",
fixNamespaceEndComments("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Support namespaces ending in semicolon Summary: This patch adds support for namespaces ending in semicolon to the namespace comment fixer. source: ``` namespace A { int i; int j; }; ``` clang-format before: ``` namespace A { int i; int j; } // namespace A; ``` clang-format after: ``` namespace A { int i; int j; }; // namespace A ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30688 llvm-svn: 297140
2017-03-07 22:07:43 +08:00
"}; // end namespace A"));
EXPECT_EQ("namespace {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Support namespaces ending in semicolon Summary: This patch adds support for namespaces ending in semicolon to the namespace comment fixer. source: ``` namespace A { int i; int j; }; ``` clang-format before: ``` namespace A { int i; int j; } // namespace A; ``` clang-format after: ``` namespace A { int i; int j; }; // namespace A ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30688 llvm-svn: 297140
2017-03-07 22:07:43 +08:00
"}; /* unnamed namespace */",
fixNamespaceEndComments("namespace {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Support namespaces ending in semicolon Summary: This patch adds support for namespaces ending in semicolon to the namespace comment fixer. source: ``` namespace A { int i; int j; }; ``` clang-format before: ``` namespace A { int i; int j; } // namespace A; ``` clang-format after: ``` namespace A { int i; int j; }; // namespace A ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30688 llvm-svn: 297140
2017-03-07 22:07:43 +08:00
"}; /* unnamed namespace */"));
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
}
clang-format: better handle namespace macros Summary: Other macros are used to declare namespaces, and should thus be handled similarly. This is the case for crpcut's TESTSUITE macro, or for unittest-cpp's SUITE macro: TESTSUITE(Foo) { TEST(MyFirstTest) { assert(0); } } // TESTSUITE(Foo) This patch deals with this cases by introducing a new option to specify lists of namespace macros. Internally, it re-uses the system already in place for foreach and statement macros, to ensure there is no impact on performance. Reviewers: krasimir, djasper, klimek Reviewed By: klimek Subscribers: acoomans, cfe-commits, klimek Tags: #clang Differential Revision: https://reviews.llvm.org/D37813 llvm-svn: 362740
2019-06-07 04:06:23 +08:00
TEST_F(NamespaceEndCommentsFixerTest, KeepsValidMacroEndComment) {
FormatStyle Style = getLLVMStyle();
Style.NamespaceMacros.push_back("TESTSUITE");
EXPECT_EQ("TESTSUITE() {\n"
"int i;\n"
"} // end anonymous TESTSUITE()",
fixNamespaceEndComments("TESTSUITE() {\n"
"int i;\n"
"} // end anonymous TESTSUITE()",
Style));
EXPECT_EQ("TESTSUITE(A) {\n"
"int i;\n"
"} /* end of TESTSUITE(A) */",
fixNamespaceEndComments("TESTSUITE(A) {\n"
"int i;\n"
"} /* end of TESTSUITE(A) */",
Style));
EXPECT_EQ("TESTSUITE(A) {\n"
"int i;\n"
"} // TESTSUITE(A)",
fixNamespaceEndComments("TESTSUITE(A) {\n"
"int i;\n"
"} // TESTSUITE(A)",
Style));
EXPECT_EQ("TESTSUITE(A::B) {\n"
"int i;\n"
"} // end TESTSUITE(A::B)",
fixNamespaceEndComments("TESTSUITE(A::B) {\n"
"int i;\n"
"} // end TESTSUITE(A::B)",
Style));
EXPECT_EQ("TESTSUITE(A) {\n"
"int i;\n"
"}; // end TESTSUITE(A)",
fixNamespaceEndComments("TESTSUITE(A) {\n"
"int i;\n"
"}; // end TESTSUITE(A)",
Style));
EXPECT_EQ("TESTSUITE() {\n"
"int i;\n"
"}; /* unnamed TESTSUITE() */",
fixNamespaceEndComments("TESTSUITE() {\n"
"int i;\n"
"}; /* unnamed TESTSUITE() */",
Style));
}
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
TEST_F(NamespaceEndCommentsFixerTest, UpdatesInvalidEndLineComment) {
EXPECT_EQ("namespace {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"} // namespace",
fixNamespaceEndComments("namespace {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"} // namespace A"));
EXPECT_EQ("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"} // namespace A",
fixNamespaceEndComments("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"} // namespace"));
EXPECT_EQ("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"} // namespace A",
fixNamespaceEndComments("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"} //"));
EXPECT_EQ("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"}; // namespace A",
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
fixNamespaceEndComments("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"}; //"));
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
EXPECT_EQ("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"} // namespace A",
fixNamespaceEndComments("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"} // banamespace A"));
[clang-format] Support namespaces ending in semicolon Summary: This patch adds support for namespaces ending in semicolon to the namespace comment fixer. source: ``` namespace A { int i; int j; }; ``` clang-format before: ``` namespace A { int i; int j; } // namespace A; ``` clang-format after: ``` namespace A { int i; int j; }; // namespace A ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30688 llvm-svn: 297140
2017-03-07 22:07:43 +08:00
EXPECT_EQ("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Support namespaces ending in semicolon Summary: This patch adds support for namespaces ending in semicolon to the namespace comment fixer. source: ``` namespace A { int i; int j; }; ``` clang-format before: ``` namespace A { int i; int j; } // namespace A; ``` clang-format after: ``` namespace A { int i; int j; }; // namespace A ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30688 llvm-svn: 297140
2017-03-07 22:07:43 +08:00
"}; // namespace A",
fixNamespaceEndComments("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Support namespaces ending in semicolon Summary: This patch adds support for namespaces ending in semicolon to the namespace comment fixer. source: ``` namespace A { int i; int j; }; ``` clang-format before: ``` namespace A { int i; int j; } // namespace A; ``` clang-format after: ``` namespace A { int i; int j; }; // namespace A ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30688 llvm-svn: 297140
2017-03-07 22:07:43 +08:00
"}; // banamespace A"));
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
// Updates invalid line comments even for short namespaces.
EXPECT_EQ("namespace A {} // namespace A",
fixNamespaceEndComments("namespace A {} // namespace"));
[clang-format] Support namespaces ending in semicolon Summary: This patch adds support for namespaces ending in semicolon to the namespace comment fixer. source: ``` namespace A { int i; int j; }; ``` clang-format before: ``` namespace A { int i; int j; } // namespace A; ``` clang-format after: ``` namespace A { int i; int j; }; // namespace A ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30688 llvm-svn: 297140
2017-03-07 22:07:43 +08:00
EXPECT_EQ("namespace A {}; // namespace A",
fixNamespaceEndComments("namespace A {}; // namespace"));
clang-format: Add CompactNamespaces option Summary: Add CompactNamespaces option, to pack namespace declarations on the same line (somewhat similar to C++17 nested namespace definition). With this option, consecutive namespace declarations are kept on the same line: namespace foo { namespace bar { ... }} // namespace foo::bar Reviewers: krasimir, djasper, klimek Reviewed By: djasper Subscribers: kimgr, cfe-commits, klimek Tags: #clang-tools-extra Differential Revision: https://reviews.llvm.org/D32480 llvm-svn: 305384
2017-06-14 20:29:47 +08:00
// Update invalid comments for compacted namespaces.
FormatStyle CompactNamespacesStyle = getLLVMStyle();
CompactNamespacesStyle.CompactNamespaces = true;
EXPECT_EQ("namespace out { namespace in {\n"
"}} // namespace out::in",
fixNamespaceEndComments("namespace out { namespace in {\n"
"}} // namespace out",
CompactNamespacesStyle));
EXPECT_EQ("namespace out { namespace in {\n"
"}} // namespace out::in",
fixNamespaceEndComments("namespace out { namespace in {\n"
"}} // namespace in",
CompactNamespacesStyle));
EXPECT_EQ("namespace out { namespace in {\n"
"}\n"
"} // namespace out::in",
fixNamespaceEndComments("namespace out { namespace in {\n"
"}// banamespace in\n"
"} // namespace out",
CompactNamespacesStyle));
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
}
clang-format: better handle namespace macros Summary: Other macros are used to declare namespaces, and should thus be handled similarly. This is the case for crpcut's TESTSUITE macro, or for unittest-cpp's SUITE macro: TESTSUITE(Foo) { TEST(MyFirstTest) { assert(0); } } // TESTSUITE(Foo) This patch deals with this cases by introducing a new option to specify lists of namespace macros. Internally, it re-uses the system already in place for foreach and statement macros, to ensure there is no impact on performance. Reviewers: krasimir, djasper, klimek Reviewed By: klimek Subscribers: acoomans, cfe-commits, klimek Tags: #clang Differential Revision: https://reviews.llvm.org/D37813 llvm-svn: 362740
2019-06-07 04:06:23 +08:00
TEST_F(NamespaceEndCommentsFixerTest, UpdatesInvalidMacroEndLineComment) {
FormatStyle Style = getLLVMStyle();
Style.NamespaceMacros.push_back("TESTSUITE");
EXPECT_EQ("TESTSUITE() {\n"
"int i;\n"
"} // TESTSUITE()",
fixNamespaceEndComments("TESTSUITE() {\n"
"int i;\n"
"} // TESTSUITE(A)",
Style));
EXPECT_EQ("TESTSUITE(A) {\n"
"int i;\n"
"} // TESTSUITE(A)",
fixNamespaceEndComments("TESTSUITE(A) {\n"
"int i;\n"
"} // TESTSUITE()",
Style));
EXPECT_EQ("TESTSUITE(A) {\n"
"int i;\n"
"} // TESTSUITE(A)",
fixNamespaceEndComments("TESTSUITE(A) {\n"
"int i;\n"
"} //",
Style));
EXPECT_EQ("TESTSUITE(A) {\n"
"int i;\n"
"}; // TESTSUITE(A)",
fixNamespaceEndComments("TESTSUITE(A) {\n"
"int i;\n"
"}; //",
Style));
EXPECT_EQ("TESTSUITE(A) {\n"
"int i;\n"
"} // TESTSUITE(A)",
fixNamespaceEndComments("TESTSUITE(A) {\n"
"int i;\n"
"} // TESTSUITE A",
Style));
EXPECT_EQ("TESTSUITE() {\n"
"int i;\n"
"} // TESTSUITE()",
fixNamespaceEndComments("TESTSUITE() {\n"
"int i;\n"
"} // TESTSUITE",
Style));
EXPECT_EQ("TESTSUITE(A) {\n"
"int i;\n"
"} // TESTSUITE(A)",
fixNamespaceEndComments("TESTSUITE(A) {\n"
"int i;\n"
"} // TOASTSUITE(A)",
Style));
EXPECT_EQ("TESTSUITE(A) {\n"
"int i;\n"
"}; // TESTSUITE(A)",
fixNamespaceEndComments("TESTSUITE(A) {\n"
"int i;\n"
"}; // TOASTSUITE(A)",
Style));
// Updates invalid line comments even for short namespaces.
EXPECT_EQ("TESTSUITE(A) {} // TESTSUITE(A)",
fixNamespaceEndComments("TESTSUITE(A) {} // TESTSUITE()", Style));
EXPECT_EQ("TESTSUITE(A) {}; // TESTSUITE(A)",
fixNamespaceEndComments("TESTSUITE(A) {}; // TESTSUITE()", Style));
// Update invalid comments for compacted namespaces.
FormatStyle CompactNamespacesStyle = getLLVMStyle();
CompactNamespacesStyle.CompactNamespaces = true;
CompactNamespacesStyle.NamespaceMacros.push_back("TESTSUITE");
EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
"}} // TESTSUITE(out::in)",
fixNamespaceEndComments("TESTSUITE(out) { TESTSUITE(in) {\n"
"}} // TESTSUITE(out)",
CompactNamespacesStyle));
EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
"}} // TESTSUITE(out::in)",
fixNamespaceEndComments("TESTSUITE(out) { TESTSUITE(in) {\n"
"}} // TESTSUITE(in)",
CompactNamespacesStyle));
EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
"}\n"
"} // TESTSUITE(out::in)",
fixNamespaceEndComments("TESTSUITE(out) { TESTSUITE(in) {\n"
"}// TAOSTSUITE(in)\n"
"} // TESTSUITE(out)",
CompactNamespacesStyle));
}
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
TEST_F(NamespaceEndCommentsFixerTest, UpdatesInvalidEndBlockComment) {
EXPECT_EQ("namespace {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"} // namespace",
fixNamespaceEndComments("namespace {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"} /* namespace A */"));
EXPECT_EQ("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"} // namespace A",
fixNamespaceEndComments("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"} /* end namespace */"));
EXPECT_EQ("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"} // namespace A",
fixNamespaceEndComments("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"} /**/"));
EXPECT_EQ("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"} // namespace A",
fixNamespaceEndComments("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"} /* end unnamed namespace */"));
EXPECT_EQ("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"} // namespace A",
fixNamespaceEndComments("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"} /* banamespace A */"));
[clang-format] Support namespaces ending in semicolon Summary: This patch adds support for namespaces ending in semicolon to the namespace comment fixer. source: ``` namespace A { int i; int j; }; ``` clang-format before: ``` namespace A { int i; int j; } // namespace A; ``` clang-format after: ``` namespace A { int i; int j; }; // namespace A ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30688 llvm-svn: 297140
2017-03-07 22:07:43 +08:00
EXPECT_EQ("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Support namespaces ending in semicolon Summary: This patch adds support for namespaces ending in semicolon to the namespace comment fixer. source: ``` namespace A { int i; int j; }; ``` clang-format before: ``` namespace A { int i; int j; } // namespace A; ``` clang-format after: ``` namespace A { int i; int j; }; // namespace A ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30688 llvm-svn: 297140
2017-03-07 22:07:43 +08:00
"}; // namespace A",
fixNamespaceEndComments("namespace A {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Support namespaces ending in semicolon Summary: This patch adds support for namespaces ending in semicolon to the namespace comment fixer. source: ``` namespace A { int i; int j; }; ``` clang-format before: ``` namespace A { int i; int j; } // namespace A; ``` clang-format after: ``` namespace A { int i; int j; }; // namespace A ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30688 llvm-svn: 297140
2017-03-07 22:07:43 +08:00
"}; /* banamespace A */"));
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
EXPECT_EQ("namespace A {} // namespace A",
fixNamespaceEndComments("namespace A {} /**/"));
[clang-format] Support namespaces ending in semicolon Summary: This patch adds support for namespaces ending in semicolon to the namespace comment fixer. source: ``` namespace A { int i; int j; }; ``` clang-format before: ``` namespace A { int i; int j; } // namespace A; ``` clang-format after: ``` namespace A { int i; int j; }; // namespace A ``` Reviewers: djasper Reviewed By: djasper Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D30688 llvm-svn: 297140
2017-03-07 22:07:43 +08:00
EXPECT_EQ("namespace A {}; // namespace A",
fixNamespaceEndComments("namespace A {}; /**/"));
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
}
clang-format: better handle namespace macros Summary: Other macros are used to declare namespaces, and should thus be handled similarly. This is the case for crpcut's TESTSUITE macro, or for unittest-cpp's SUITE macro: TESTSUITE(Foo) { TEST(MyFirstTest) { assert(0); } } // TESTSUITE(Foo) This patch deals with this cases by introducing a new option to specify lists of namespace macros. Internally, it re-uses the system already in place for foreach and statement macros, to ensure there is no impact on performance. Reviewers: krasimir, djasper, klimek Reviewed By: klimek Subscribers: acoomans, cfe-commits, klimek Tags: #clang Differential Revision: https://reviews.llvm.org/D37813 llvm-svn: 362740
2019-06-07 04:06:23 +08:00
TEST_F(NamespaceEndCommentsFixerTest, UpdatesInvalidMacroEndBlockComment) {
FormatStyle Style = getLLVMStyle();
Style.NamespaceMacros.push_back("TESTSUITE");
EXPECT_EQ("TESTSUITE() {\n"
"int i;\n"
"} // TESTSUITE()",
fixNamespaceEndComments("TESTSUITE() {\n"
"int i;\n"
"} /* TESTSUITE(A) */",
Style));
EXPECT_EQ("TESTSUITE(A) {\n"
"int i;\n"
"} // TESTSUITE(A)",
fixNamespaceEndComments("TESTSUITE(A) {\n"
"int i;\n"
"} /* end TESTSUITE() */",
Style));
EXPECT_EQ("TESTSUITE(A) {\n"
"int i;\n"
"} // TESTSUITE(A)",
fixNamespaceEndComments("TESTSUITE(A) {\n"
"int i;\n"
"} /**/",
Style));
EXPECT_EQ("TESTSUITE(A) {\n"
"int i;\n"
"} // TESTSUITE(A)",
fixNamespaceEndComments("TESTSUITE(A) {\n"
"int i;\n"
"} /* end unnamed TESTSUITE() */",
Style));
EXPECT_EQ("TESTSUITE(A) {\n"
"int i;\n"
"} // TESTSUITE(A)",
fixNamespaceEndComments("TESTSUITE(A) {\n"
"int i;\n"
"} /* TOASTSUITE(A) */",
Style));
EXPECT_EQ("TESTSUITE(A) {\n"
"int i;\n"
"}; // TESTSUITE(A)",
fixNamespaceEndComments("TESTSUITE(A) {\n"
"int i;\n"
"}; /* TAOSTSUITE(A) */",
Style));
EXPECT_EQ("TESTSUITE(A) {} // TESTSUITE(A)",
fixNamespaceEndComments("TESTSUITE(A) {} /**/", Style));
EXPECT_EQ("TESTSUITE(A) {}; // TESTSUITE(A)",
fixNamespaceEndComments("TESTSUITE(A) {}; /**/", Style));
}
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
TEST_F(NamespaceEndCommentsFixerTest,
DoesNotAddEndCommentForNamespacesControlledByMacros) {
EXPECT_EQ("#ifdef 1\n"
"namespace A {\n"
"#elseif\n"
"namespace B {\n"
"#endif\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}\n"
"}\n",
fixNamespaceEndComments("#ifdef 1\n"
"namespace A {\n"
"#elseif\n"
"namespace B {\n"
"#endif\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}\n"
"}\n"));
}
[clang-format][PR47290] Add ShortNamespaceLines format option clang-format documentation states that having enabled FixNamespaceComments one may expect below code: c++ namespace a { foo(); } to be turned into: c++ namespace a { foo(); } // namespace a In reality, no "// namespace a" was added. The problem was too high value of kShortNamespaceMaxLines, which is used while deciding whether a namespace is long enough to be formatted. As with 9163fe2, clang-format idempotence is preserved. Differential Revision: https://reviews.llvm.org/D87587
2021-03-02 04:15:04 +08:00
TEST_F(NamespaceEndCommentsFixerTest, AddsEndCommentForNamespacesAroundMacros) {
clang-format: fix block OpeningLineIndex around preprocessor Summary: The current code would return an incorrect value when a preprocessor directive is present immediately after the opening brace: this causes the nanespace end comment fixer to break in some places, for exemple it would not add the comment in this case: namespace a { #define FOO } Fixing the computation is simple enough, but it was breaking a feature, as it would cause comments to be added also when the namespace declaration was dependant on conditional compilation. To fix this, a hash of the current preprocessor stack/branches is computed at the beginning of parseBlock(), so that we explicitely do not store the OpeningLineIndex when the beginning and end of the block are not in the same preprocessor conditions. Tthe hash is computed based on the line, but this could propbably be improved by using the actual condition, so that clang-format would be able to match multiple identical #ifdef blocks. Reviewers: krasimir, djasper Reviewed By: krasimir Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D35483 llvm-svn: 309369
2017-07-28 15:56:14 +08:00
// Conditional blocks around are fine
EXPECT_EQ("namespace A {\n"
"#if 1\n"
"int i;\n"
"#endif\n"
"}// namespace A",
fixNamespaceEndComments("namespace A {\n"
"#if 1\n"
"int i;\n"
"#endif\n"
"}"));
EXPECT_EQ("#if 1\n"
"#endif\n"
"namespace A {\n"
"int i;\n"
"int j;\n"
"}// namespace A",
fixNamespaceEndComments("#if 1\n"
"#endif\n"
"namespace A {\n"
"int i;\n"
"int j;\n"
"}"));
EXPECT_EQ("namespace A {\n"
"int i;\n"
"int j;\n"
"}// namespace A\n"
"#if 1\n"
"#endif",
fixNamespaceEndComments("namespace A {\n"
"int i;\n"
"int j;\n"
"}\n"
"#if 1\n"
"#endif"));
EXPECT_EQ("#if 1\n"
"namespace A {\n"
"int i;\n"
"int j;\n"
"}// namespace A\n"
"#endif",
fixNamespaceEndComments("#if 1\n"
"namespace A {\n"
"int i;\n"
"int j;\n"
"}\n"
"#endif"));
// Macro definition has no impact
EXPECT_EQ("namespace A {\n"
"#define FOO\n"
"int i;\n"
"}// namespace A",
fixNamespaceEndComments("namespace A {\n"
"#define FOO\n"
"int i;\n"
"}"));
EXPECT_EQ("#define FOO\n"
"namespace A {\n"
"int i;\n"
"int j;\n"
"}// namespace A",
fixNamespaceEndComments("#define FOO\n"
"namespace A {\n"
"int i;\n"
"int j;\n"
"}"));
EXPECT_EQ("namespace A {\n"
"int i;\n"
"int j;\n"
"}// namespace A\n"
"#define FOO\n",
fixNamespaceEndComments("namespace A {\n"
"int i;\n"
"int j;\n"
"}\n"
"#define FOO\n"));
// No replacement if open & close in different conditional blocks
EXPECT_EQ("#if 1\n"
"namespace A {\n"
"#endif\n"
"int i;\n"
"int j;\n"
"#if 1\n"
"}\n"
"#endif",
fixNamespaceEndComments("#if 1\n"
"namespace A {\n"
"#endif\n"
"int i;\n"
"int j;\n"
"#if 1\n"
"}\n"
"#endif"));
EXPECT_EQ("#ifdef A\n"
"namespace A {\n"
"#endif\n"
"int i;\n"
"int j;\n"
"#ifdef B\n"
"}\n"
"#endif",
fixNamespaceEndComments("#ifdef A\n"
"namespace A {\n"
"#endif\n"
"int i;\n"
"int j;\n"
"#ifdef B\n"
"}\n"
"#endif"));
// No replacement inside unreachable conditional block
EXPECT_EQ("#if 0\n"
"namespace A {\n"
"int i;\n"
"int j;\n"
"}\n"
"#endif",
fixNamespaceEndComments("#if 0\n"
"namespace A {\n"
"int i;\n"
"int j;\n"
"}\n"
"#endif"));
}
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
TEST_F(NamespaceEndCommentsFixerTest,
DoesNotAddEndCommentForNamespacesInMacroDeclarations) {
EXPECT_EQ("#ifdef 1\n"
"namespace A {\n"
"#elseif\n"
"namespace B {\n"
"#endif\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}\n"
"}\n",
fixNamespaceEndComments("#ifdef 1\n"
"namespace A {\n"
"#elseif\n"
"namespace B {\n"
"#endif\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
"}\n"
"}\n"));
[clang-format] Make NamespaceEndCommentFixer add at most one comment Summary: Until now, NamespaceEndCommentFixer was adding missing comments for every run, which results in multiple end comments for: ``` namespace { int i; int j; } #if A int a = 1; #else int a = 2; #endif ``` result before: ``` namespace { int i; int j; }// namespace // namespace #if A int a = 1; #else int a = 2; #endif ``` result after: ``` namespace { int i; int j; }// namespace #if A int a = 1; #else int a = 2; #endif ``` Reviewers: djasper Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D30659 llvm-svn: 297028
2017-03-07 00:44:45 +08:00
EXPECT_EQ("namespace {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"int j;\n"
[clang-format] Make NamespaceEndCommentFixer add at most one comment Summary: Until now, NamespaceEndCommentFixer was adding missing comments for every run, which results in multiple end comments for: ``` namespace { int i; int j; } #if A int a = 1; #else int a = 2; #endif ``` result before: ``` namespace { int i; int j; }// namespace // namespace #if A int a = 1; #else int a = 2; #endif ``` result after: ``` namespace { int i; int j; }// namespace #if A int a = 1; #else int a = 2; #endif ``` Reviewers: djasper Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D30659 llvm-svn: 297028
2017-03-07 00:44:45 +08:00
"}// namespace\n"
"#if A\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Make NamespaceEndCommentFixer add at most one comment Summary: Until now, NamespaceEndCommentFixer was adding missing comments for every run, which results in multiple end comments for: ``` namespace { int i; int j; } #if A int a = 1; #else int a = 2; #endif ``` result before: ``` namespace { int i; int j; }// namespace // namespace #if A int a = 1; #else int a = 2; #endif ``` result after: ``` namespace { int i; int j; }// namespace #if A int a = 1; #else int a = 2; #endif ``` Reviewers: djasper Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D30659 llvm-svn: 297028
2017-03-07 00:44:45 +08:00
"#else\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int j;\n"
[clang-format] Make NamespaceEndCommentFixer add at most one comment Summary: Until now, NamespaceEndCommentFixer was adding missing comments for every run, which results in multiple end comments for: ``` namespace { int i; int j; } #if A int a = 1; #else int a = 2; #endif ``` result before: ``` namespace { int i; int j; }// namespace // namespace #if A int a = 1; #else int a = 2; #endif ``` result after: ``` namespace { int i; int j; }// namespace #if A int a = 1; #else int a = 2; #endif ``` Reviewers: djasper Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D30659 llvm-svn: 297028
2017-03-07 00:44:45 +08:00
"#endif",
fixNamespaceEndComments("namespace {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
"int j;\n"
[clang-format] Make NamespaceEndCommentFixer add at most one comment Summary: Until now, NamespaceEndCommentFixer was adding missing comments for every run, which results in multiple end comments for: ``` namespace { int i; int j; } #if A int a = 1; #else int a = 2; #endif ``` result before: ``` namespace { int i; int j; }// namespace // namespace #if A int a = 1; #else int a = 2; #endif ``` result after: ``` namespace { int i; int j; }// namespace #if A int a = 1; #else int a = 2; #endif ``` Reviewers: djasper Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D30659 llvm-svn: 297028
2017-03-07 00:44:45 +08:00
"}\n"
"#if A\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Make NamespaceEndCommentFixer add at most one comment Summary: Until now, NamespaceEndCommentFixer was adding missing comments for every run, which results in multiple end comments for: ``` namespace { int i; int j; } #if A int a = 1; #else int a = 2; #endif ``` result before: ``` namespace { int i; int j; }// namespace // namespace #if A int a = 1; #else int a = 2; #endif ``` result after: ``` namespace { int i; int j; }// namespace #if A int a = 1; #else int a = 2; #endif ``` Reviewers: djasper Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D30659 llvm-svn: 297028
2017-03-07 00:44:45 +08:00
"#else\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int j;\n"
[clang-format] Make NamespaceEndCommentFixer add at most one comment Summary: Until now, NamespaceEndCommentFixer was adding missing comments for every run, which results in multiple end comments for: ``` namespace { int i; int j; } #if A int a = 1; #else int a = 2; #endif ``` result before: ``` namespace { int i; int j; }// namespace // namespace #if A int a = 1; #else int a = 2; #endif ``` result after: ``` namespace { int i; int j; }// namespace #if A int a = 1; #else int a = 2; #endif ``` Reviewers: djasper Reviewed By: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D30659 llvm-svn: 297028
2017-03-07 00:44:45 +08:00
"#endif"));
[clang-format] Add tests for ambiguous namespaces to the comment fixer llvm-svn: 297034
2017-03-07 01:29:25 +08:00
EXPECT_EQ("#if A\n"
"namespace A {\n"
"#else\n"
"namespace B {\n"
"#endif\n"
"int i;\n"
"int j;\n"
"}",
fixNamespaceEndComments("#if A\n"
"namespace A {\n"
"#else\n"
"namespace B {\n"
"#endif\n"
"int i;\n"
"int j;\n"
"}"));
EXPECT_EQ("#if A\n"
"namespace A {\n"
"#else\n"
"namespace B {\n"
"#endif\n"
"int i;\n"
"int j;\n"
"} // namespace A",
fixNamespaceEndComments("#if A\n"
"namespace A {\n"
"#else\n"
"namespace B {\n"
"#endif\n"
"int i;\n"
"int j;\n"
"} // namespace A"));
EXPECT_EQ("#if A\n"
"namespace A {\n"
"#else\n"
"namespace B {\n"
"#endif\n"
"int i;\n"
"int j;\n"
"} // namespace B",
fixNamespaceEndComments("#if A\n"
"namespace A {\n"
"#else\n"
"namespace B {\n"
"#endif\n"
"int i;\n"
"int j;\n"
"} // namespace B"));
EXPECT_EQ("namespace A\n"
"int i;\n"
"int j;\n"
"#if A\n"
"}\n"
"#else\n"
"}\n"
"#endif",
fixNamespaceEndComments("namespace A\n"
"int i;\n"
"int j;\n"
"#if A\n"
"}\n"
"#else\n"
"}\n"
"#endif"));
EXPECT_EQ("namespace A\n"
"int i;\n"
"int j;\n"
"#if A\n"
"} // namespace A\n"
"#else\n"
"} // namespace A\n"
"#endif",
fixNamespaceEndComments("namespace A\n"
"int i;\n"
"int j;\n"
"#if A\n"
"} // namespace A\n"
"#else\n"
"} // namespace A\n"
"#endif"));
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
}
[clang-format] Don't add namespace end comments for unbalanced right braces after namespace end llvm-svn: 296638
2017-03-02 00:38:08 +08:00
TEST_F(NamespaceEndCommentsFixerTest,
DoesNotAddEndCommentForUnbalancedRBracesAfterNamespaceEnd) {
EXPECT_EQ("namespace {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Don't add namespace end comments for unbalanced right braces after namespace end llvm-svn: 296638
2017-03-02 00:38:08 +08:00
"} // namespace\n"
"}",
fixNamespaceEndComments("namespace {\n"
[NFC] clang-format: Use LLVM style in NamespaceEndCommentsFixerTest As pointed out in https://reviews.llvm.org/D37813#inline-555026, the code which is formatted does not match LLVM formatting style. Technically this is not a problem since these tests bypass most of the formatter, but it can be misleading. llvm-svn: 361984
2019-05-30 00:22:43 +08:00
"int i;\n"
[clang-format] Don't add namespace end comments for unbalanced right braces after namespace end llvm-svn: 296638
2017-03-02 00:38:08 +08:00
"} // namespace\n"
"}"));
}
[clang-format] fix crash in NamespaceEndCommentsFixer (PR32438) Summary: The new test case was crashing before. Now it passes as expected. Reviewers: djasper Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D31441 llvm-svn: 299465
2017-04-05 04:11:13 +08:00
TEST_F(NamespaceEndCommentsFixerTest, HandlesInlineAtEndOfLine_PR32438) {
EXPECT_EQ("template <int> struct a {};\n"
"struct a<bool{}> b() {\n"
"}\n"
"#define c inline\n"
"void d() {\n"
"}\n",
fixNamespaceEndComments("template <int> struct a {};\n"
"struct a<bool{}> b() {\n"
"}\n"
"#define c inline\n"
"void d() {\n"
"}\n"));
}
[clang-format] [PR46130] When editing a file with unbalance {} the namespace comment fixer can incorrectly comment the wrong closing brace Summary: https://bugs.llvm.org/show_bug.cgi?id=46130 from Twitter https://twitter.com/ikautak/status/1265998988232159232 I have seen this myself many times.. if you have format on save and you work in an editor where you are constantly saving (:w muscle memory) If you are in the middle of editing and somehow you've missed a { or } in your code, somewhere, often way below where you are at the bottom of your file the namespace comment fixer will have put the namespace on the previous closing brace. This leads to you having to fix up the bottom of the file. This revision prevents that happening by performing an initial pass of the tokens and simply counting the number of `{` and `}` and ensuring they balance. If they don't balance we don't do any namespace fixing as it will likely be unstable and incorrect. Reviewed By: curdeius Subscribers: cfe-commits Tags: #clang, #clang-format Differential Revision: https://reviews.llvm.org/D80830
2020-05-30 20:00:35 +08:00
TEST_F(NamespaceEndCommentsFixerTest, IgnoreUnbalanced) {
EXPECT_EQ("namespace A {\n"
"class Foo {\n"
"}\n"
"}// namespace A\n",
fixNamespaceEndComments("namespace A {\n"
"class Foo {\n"
"}\n"
"}\n"));
EXPECT_EQ("namespace A {\n"
"class Foo {\n"
"}\n",
fixNamespaceEndComments("namespace A {\n"
"class Foo {\n"
"}\n"));
EXPECT_EQ("namespace A {\n"
"class Foo {\n"
"}\n"
"}\n"
"}\n",
fixNamespaceEndComments("namespace A {\n"
"class Foo {\n"
"}\n"
"}\n"
"}\n"));
}
[clang-format][PR47290] Add ShortNamespaceLines format option clang-format documentation states that having enabled FixNamespaceComments one may expect below code: c++ namespace a { foo(); } to be turned into: c++ namespace a { foo(); } // namespace a In reality, no "// namespace a" was added. The problem was too high value of kShortNamespaceMaxLines, which is used while deciding whether a namespace is long enough to be formatted. As with 9163fe2, clang-format idempotence is preserved. Differential Revision: https://reviews.llvm.org/D87587
2021-03-02 04:15:04 +08:00
using ShortNamespaceLinesTest = NamespaceEndCommentsFixerTest;
TEST_F(ShortNamespaceLinesTest, ZeroUnwrappedLines) {
auto Style = getLLVMStyle();
Style.ShortNamespaceLines = 0u;
EXPECT_EQ("namespace OneLinerNamespace {}\n",
fixNamespaceEndComments("namespace OneLinerNamespace {}\n", Style));
EXPECT_EQ("namespace ShortNamespace {\n"
"}\n",
fixNamespaceEndComments("namespace ShortNamespace {\n"
"}\n",
Style));
EXPECT_EQ("namespace LongNamespace {\n"
"int i;\n"
"}// namespace LongNamespace\n",
fixNamespaceEndComments("namespace LongNamespace {\n"
"int i;\n"
"}\n",
Style));
}
TEST_F(ShortNamespaceLinesTest, OneUnwrappedLine) {
constexpr auto DefaultUnwrappedLines = 1u;
auto const Style = getLLVMStyle();
EXPECT_EQ(DefaultUnwrappedLines, Style.ShortNamespaceLines);
EXPECT_EQ("namespace ShortNamespace {\n"
"int i;\n"
"}\n",
fixNamespaceEndComments("namespace ShortNamespace {\n"
"int i;\n"
"}\n"));
EXPECT_EQ("namespace LongNamespace {\n"
"int i;\n"
"int j;\n"
"}// namespace LongNamespace\n",
fixNamespaceEndComments("namespace LongNamespace {\n"
"int i;\n"
"int j;\n"
"}\n"));
}
TEST_F(ShortNamespaceLinesTest, MultipleUnwrappedLine) {
auto Style = getLLVMStyle();
Style.ShortNamespaceLines = 2u;
EXPECT_EQ("namespace ShortNamespace {\n"
"int i;\n"
"int j;\n"
"}\n",
fixNamespaceEndComments("namespace ShortNamespace {\n"
"int i;\n"
"int j;\n"
"}\n",
Style));
EXPECT_EQ("namespace LongNamespace {\n"
"int i;\n"
"int j;\n"
"int k;\n"
"}// namespace LongNamespace\n",
fixNamespaceEndComments("namespace LongNamespace {\n"
"int i;\n"
"int j;\n"
"int k;\n"
"}\n",
Style));
}
[clang-format] FixNamespaceComments does not understand namespace aliases https://github.com/llvm/llvm-project/issues/35876 Ensure a namespace alias doesn't get incorrectly identifier as a namespace Reviewed By: HazardyKnusperkeks, curdeius, owenpan Differential Revision: https://reviews.llvm.org/D115647 Fixes: #35876
2021-12-14 22:45:26 +08:00
TEST_F(ShortNamespaceLinesTest, NamespaceAlias) {
auto Style = getLLVMStyle();
EXPECT_EQ("namespace n = nn;\n"
"{\n"
" int i;\n"
" int j;\n"
"}\n",
fixNamespaceEndComments("namespace n = nn;\n"
"{\n"
" int i;\n"
" int j;\n"
"}\n",
Style));
EXPECT_EQ("namespace n = nn; // comment\n"
"{\n"
" int i;\n"
" int j;\n"
"}\n",
fixNamespaceEndComments("namespace n = nn; // comment\n"
"{\n"
" int i;\n"
" int j;\n"
"}\n",
Style));
EXPECT_EQ("namespace n = nn; /* comment */\n"
"{\n"
" int i;\n"
" int j;\n"
"}\n",
fixNamespaceEndComments("namespace n = nn; /* comment */\n"
"{\n"
" int i;\n"
" int j;\n"
"}\n",
Style));
EXPECT_EQ(
"namespace n = nn; /* comment */ /* comment2 */\n"
"{\n"
" int i;\n"
" int j;\n"
"}\n",
fixNamespaceEndComments("namespace n = nn; /* comment */ /* comment2 */\n"
"{\n"
" int i;\n"
" int j;\n"
"}\n",
Style));
EXPECT_EQ("namespace n = nn; {\n"
" int i;\n"
" int j;\n"
"}\n",
fixNamespaceEndComments("namespace n = nn; {\n"
" int i;\n"
" int j;\n"
"}\n",
Style));
EXPECT_EQ("int foo;\n"
"namespace n\n"
"{\n"
" int i;\n"
" int j;\n"
"}// namespace n\n",
fixNamespaceEndComments("int foo;\n"
"namespace n\n"
"{\n"
" int i;\n"
" int j;\n"
"}\n",
Style));
}
[clang-format] Add a NamespaceEndCommentsFixer Summary: This patch adds a NamespaceEndCommentsFixer TokenAnalyzer for clang-format, which fixes end namespace comments. It currently supports inserting and updating existing wrong comments. Example source: ``` namespace A { int i; } namespace B { int j; } // namespace A ``` after formatting: ``` namespace A { int i; } // namespace A namespace B { int j; } // namespace B ``` Reviewers: klimek, djasper Reviewed By: djasper Subscribers: klimek, mgorny Differential Revision: https://reviews.llvm.org/D30269 llvm-svn: 296341
2017-02-27 21:28:36 +08:00
} // end namespace
} // end namespace format
} // end namespace clang