maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

clang-format: Fix formatting C++ namespaces with preceding 'inline' or 'export' specifier 

This fixes formatting namespaces with preceding 'inline' and 'export' (Modules TS) specifiers.

This change fixes namespaces not being identified as such with preceding 'inline' or 'export' specifiers.

Motivation: I was experimenting with the Modules TS (-fmodules-ts) and found it would be useful if clang-format would correctly format 'export namespace'. While making the changes, I noticed that similar issues still exist with 'inline namespace', and addressed them as well.

Patch by Marco Elver!

Reviewers: klimek, djasper, owenpan, sammccall

Reviewed By: owenpan, sammccall

Subscribers: owenpan, cfe-commits

Differential Revision: https://reviews.llvm.org/D51036

llvm-svn: 341450
This commit is contained in:
Sam McCall 2018-09-05 07:44:02 +00:00
parent f592d281a7
commit 6f3778c372
7 changed files with 99 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
clang/lib/Format/Format.cpp
View File

@ -1309,8 +1309,7 @@ private:
std::set<unsigned> DeletedLines;
for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
auto &Line = *AnnotatedLines[i];
if (Line.startsWith(tok::kw_namespace) ||
Line.startsWith(tok::kw_inline, tok::kw_namespace)) {
if (Line.startsWithNamespace()) {
checkEmptyNamespace(AnnotatedLines, i, i, DeletedLines);
}
}
@ -1347,9 +1346,7 @@ private:
if (AnnotatedLines[CurrentLine]->startsWith(tok::r_brace))
break;
if (AnnotatedLines[CurrentLine]->startsWith(tok::kw_namespace) ||
AnnotatedLines[CurrentLine]->startsWith(tok::kw_inline,
tok::kw_namespace)) {
if (AnnotatedLines[CurrentLine]->startsWithNamespace()) {
if (!checkEmptyNamespace(AnnotatedLines, CurrentLine, NewLine,
DeletedLines))
return false;

4
clang/lib/Format/FormatToken.h
View File

@ -520,8 +520,8 @@ struct FormatToken {
const FormatToken *NamespaceTok = this;
if (is(tok::comment))
NamespaceTok = NamespaceTok->getNextNonComment();
// Detect "(inline)? namespace" in the beginning of a line.
if (NamespaceTok && NamespaceTok->is(tok::kw_inline))
// Detect "(inline|export)? namespace" in the beginning of a line.
if (NamespaceTok && NamespaceTok->isOneOf(tok::kw_inline, tok::kw_export))
NamespaceTok = NamespaceTok->getNextNonComment();
return NamespaceTok && NamespaceTok->is(tok::kw_namespace) ? NamespaceTok
: nullptr;

7
clang/lib/Format/NamespaceEndCommentsFixer.cpp
View File

@ -125,12 +125,7 @@ getNamespaceToken(const AnnotatedLine *Line,
if (StartLineIndex > 0)
NamespaceTok = AnnotatedLines[StartLineIndex - 1]->First;
}
// Detect "(inline)? namespace" in the beginning of a line.
if (NamespaceTok->is(tok::kw_inline))
NamespaceTok = NamespaceTok->getNextNonComment();
if (!NamespaceTok || NamespaceTok->isNot(tok::kw_namespace))
return nullptr;
return NamespaceTok;
return NamespaceTok->getNamespaceToken();
}
NamespaceEndCommentsFixer::NamespaceEndCommentsFixer(const Environment &Env,

7
clang/lib/Format/TokenAnnotator.h
View File

@ -105,6 +105,13 @@ public:
return !Last->isOneOf(tok::semi, tok::comment);
}
/// \c true if this line starts a namespace definition.
bool startsWithNamespace() const {
return startsWith(tok::kw_namespace) ||
startsWith(tok::kw_inline, tok::kw_namespace) ||
startsWith(tok::kw_export, tok::kw_namespace);
}
FormatToken *First;
FormatToken *Last;

4
clang/lib/Format/UnwrappedLineFormatter.cpp
View File

@ -535,7 +535,7 @@ private:
Tok->SpacesRequiredBefore = 0;
Tok->CanBreakBefore = true;
return 1;
} else if (Limit != 0 && !Line.startsWith(tok::kw_namespace) &&
} else if (Limit != 0 && !Line.startsWithNamespace() &&
!startsExternCBlock(Line)) {
// We don't merge short records.
FormatToken *RecordTok = Line.First;
@ -1160,7 +1160,7 @@ void UnwrappedLineFormatter::formatFirstToken(
// Remove empty lines after "{".
if (!Style.KeepEmptyLinesAtTheStartOfBlocks && PreviousLine &&
PreviousLine->Last->is(tok::l_brace) &&
PreviousLine->First->isNot(tok::kw_namespace) &&
!PreviousLine->startsWithNamespace() &&
!startsExternCBlock(*PreviousLine))
Newlines = 1;

17
clang/lib/Format/UnwrappedLineParser.cpp
View File

@ -992,13 +992,6 @@ void UnwrappedLineParser::parseStructuralElement() {
case tok::kw_namespace:
parseNamespace();
return;
case tok::kw_inline:
nextToken();
if (FormatTok->Tok.is(tok::kw_namespace)) {
parseNamespace();
return;
}
break;
case tok::kw_public:
case tok::kw_protected:
case tok::kw_private:
@ -1066,6 +1059,16 @@ void UnwrappedLineParser::parseStructuralElement() {
parseJavaScriptEs6ImportExport();
return;
}
if (!Style.isCpp())
break;
// Handle C++ "(inline|export) namespace".
LLVM_FALLTHROUGH;
case tok::kw_inline:
nextToken();
if (FormatTok->Tok.is(tok::kw_namespace)) {
parseNamespace();
return;
}
break;
case tok::identifier:
if (FormatTok->is(TT_ForEachMacro)) {

75
clang/unittests/Format/FormatTest.cpp
View File

@ -200,6 +200,42 @@ TEST_F(FormatTest, RemovesEmptyLines) {
"int i;\n"
"}",
getGoogleStyle()));
EXPECT_EQ("/* something */ namespace N {\n"
"\n"
"int i;\n"
"}",
format("/* something */ namespace N {\n"
"\n"
"int i;\n"
"}",
getGoogleStyle()));
EXPECT_EQ("inline namespace N {\n"
"\n"
"int i;\n"
"}",
format("inline namespace N {\n"
"\n"
"int i;\n"
"}",
getGoogleStyle()));
EXPECT_EQ("/* something */ inline namespace N {\n"
"\n"
"int i;\n"
"}",
format("/* something */ inline namespace N {\n"
"\n"
"int i;\n"
"}",
getGoogleStyle()));
EXPECT_EQ("export namespace N {\n"
"\n"
"int i;\n"
"}",
format("export namespace N {\n"
"\n"
"int i;\n"
"}",
getGoogleStyle()));
EXPECT_EQ("extern /**/ \"C\" /**/ {\n"
"\n"
"int i;\n"
@ -1220,12 +1256,25 @@ TEST_F(FormatTest, UnderstandsAccessSpecifiers) {
"private:\n"
" void f() {}\n"
"};");
verifyFormat("export class A {\n"
"public:\n"
"public: // comment\n"
"protected:\n"
"private:\n"
" void f() {}\n"
"};");
verifyGoogleFormat("class A {\n"
" public:\n"
" protected:\n"
" private:\n"
" void f() {}\n"
"};");
verifyGoogleFormat("export class A {\n"
" public:\n"
" protected:\n"
" private:\n"
" void f() {}\n"
"};");
verifyFormat("class A {\n"
"public slots:\n"
" void f1() {}\n"
@ -1597,16 +1646,36 @@ TEST_F(FormatTest, FormatsNamespaces) {
"void f() { f(); }\n"
"}",
LLVMWithNoNamespaceFix);
verifyFormat("/* something */ namespace some_namespace {\n"
"class A {};\n"
"void f() { f(); }\n"
"}",
LLVMWithNoNamespaceFix);
verifyFormat("namespace {\n"
"class A {};\n"
"void f() { f(); }\n"
"}",
LLVMWithNoNamespaceFix);
verifyFormat("/* something */ namespace {\n"
"class A {};\n"
"void f() { f(); }\n"
"}",
LLVMWithNoNamespaceFix);
verifyFormat("inline namespace X {\n"
"class A {};\n"
"void f() { f(); }\n"
"}",
LLVMWithNoNamespaceFix);
verifyFormat("/* something */ inline namespace X {\n"
"class A {};\n"
"void f() { f(); }\n"
"}",
LLVMWithNoNamespaceFix);
verifyFormat("export namespace X {\n"
"class A {};\n"
"void f() { f(); }\n"
"}",
LLVMWithNoNamespaceFix);
verifyFormat("using namespace some_namespace;\n"
"class A {};\n"
"void f() { f(); }",
@ -7602,6 +7671,12 @@ TEST_F(FormatTest, SplitEmptyNamespace) {
verifyFormat("inline namespace Foo\n"
"{};",
Style);
verifyFormat("/* something */ inline namespace Foo\n"
"{};",
Style);
verifyFormat("export namespace Foo\n"
"{};",
Style);
verifyFormat("namespace Foo\n"
"{\n"
"void Bar();\n"