Fixes detection of class template specializations.

Now correctly formats:
template <> class A<int> {} a;

llvm-svn: 173038

2 files changed, 22 insertions, 1 deletions

diff --git a/clang/lib/Format/UnwrappedLineParser.cpp b/clang/lib/Format/UnwrappedLineParser.cpp
index dffc309a09e..7f9e97eab00 100644
--- a/clang/lib/Format/UnwrappedLineParser.cpp
+++ b/clang/lib/Format/UnwrappedLineParser.cpp
@@ -620,7 +620,17 @@ void UnwrappedLineParser::parseRecord() {
            FormatTok.Tok.is(tok::coloncolon))
       nextToken();
 
-    if (FormatTok.Tok.is(tok::colon)) {
+    // Note that parsing away template declarations here leads to incorrectly
+    // accepting function declarations as record declarations.
+    // In general, we cannot solve this problem. Consider:
+    // class A<int> B() {}
+    // which can be a function definition or a class definition when B() is a
+    // macro. If we find enough real-world cases where this is a problem, we
+    // can parse for the 'template' keyword in the beginning of the statement,
+    // and thus rule out the record production in case there is no template
+    // (this would still leave us with an ambiguity between template function
+    // and class declarations).
+    if (FormatTok.Tok.is(tok::colon) || FormatTok.Tok.is(tok::less)) {
       while (FormatTok.Tok.isNot(tok::l_brace)) {
         if (FormatTok.Tok.is(tok::semi))
           return;
@@ -630,6 +640,9 @@ void UnwrappedLineParser::parseRecord() {
   }
   if (FormatTok.Tok.is(tok::l_brace))
     parseBlock();
+  // We fall through to parsing a structural element afterwards, so
+  // class A {} n, m;
+  // will end up in one unwrapped line.
 }
 
 void UnwrappedLineParser::parseObjCProtocolList() {
diff --git a/clang/unittests/Format/FormatTest.cpp b/clang/unittests/Format/FormatTest.cpp
index 3c929a3f532..4725889247e 100644
--- a/clang/unittests/Format/FormatTest.cpp
+++ b/clang/unittests/Format/FormatTest.cpp
@@ -1530,6 +1530,14 @@ TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) {
   // Redefinition from nested context:
   verifyFormat("class A::B::C {} n;");
 
+  // Template definitions.
+  // FIXME: This is still incorrectly handled at the formatter side.
+  verifyFormat("template <> struct X < 15, i < 3 && 42 < 50 && 33<28> {};");
+
+  // FIXME:
+  // This now gets parsed incorrectly as class definition.
+  // verifyFormat("class A<int> f() {}\nint n;");
+
   // Elaborate types where incorrectly parsing the structural element would
   // break the indent.
   verifyFormat("if (true)\n"