[clang-format] Handle leading comments in using declaration

[sugak]

Summary

This fixes clang-format internal assertion for the following code:

/* override */ using std::string;

Added add a unit test.

[sugak]

lib/Format/UsingDeclarationsSorter.cpp

50

and this is the assertions that fails for the code referenced in the summary.

[djasper]

Some minor remarks, but generally looks good. Thanks for fixing this!

lib/Format/UsingDeclarationsSorter.cpp

136

const auto *FirstTok

or

const FormatToken *FirstTok

142

We don't use braces around single-statement ifs in LLVM style.

145

const auto *UsingTok

or

const FormatToken *UsingTok

[sugak]

Updated per comments.

@djasper : Thank you for the review! Would you commit this for me?

[sugak]

@djasper: ping :)

[djasper]

Looks good. Do you have submit access?

[sugak]

@djasper: no, I do not.

[djasper]

Submitted as r317901.

lib/Format/UsingDeclarationsSorter.cpp

 /// \p UsingTok.
 /// If \p UsingTok doesn't begin a using declaration, returns the empty string.
 /// Note that this detects specifically using declarations, as in:
 /// using A::B::C;
 /// and not type aliases, as in:
 /// using A = B::C;
 /// Type aliases are in general not safe to permute.
 std::string computeUsingDeclarationLabel(const FormatToken *UsingTok) {
   assert(UsingTok && UsingTok->is(tok::kw_using) && "Expecting a using token");
   std::string Label;
   const FormatToken *Tok = UsingTok->Next;
   if (Tok && Tok->is(tok::kw_typename)) {
     Label.append("typename ");
     Tok = Tok->Next;
   }
   if (Tok && Tok->is(tok::coloncolon)) {
     Label.append("::");
std::pair<tooling::Replacements, unsigned> UsingDeclarationsSorter::analyze(
     TokenAnnotator &Annotator, SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
     FormatTokenLexer &Tokens) {
   const SourceManager &SourceMgr = Env.getSourceManager();
   AffectedRangeMgr.computeAffectedLines(AnnotatedLines.begin(),
                                         AnnotatedLines.end());
   tooling::Replacements Fixes;
   SmallVector<UsingDeclaration, 4> UsingDeclarations;
   for (size_t I = 0, E = AnnotatedLines.size(); I != E; ++I) {
+    const auto *FirstTok = AnnotatedLines[I]->First;
     if (AnnotatedLines[I]->InPPDirective ||
-        !AnnotatedLines[I]->startsWith(tok::kw_using) ||
-        AnnotatedLines[I]->First->Finalized) {
+        !AnnotatedLines[I]->startsWith(tok::kw_using) || FirstTok->Finalized) {
       endUsingDeclarationBlock(&UsingDeclarations, SourceMgr, &Fixes);
       continue;
     }
-    if (AnnotatedLines[I]->First->NewlinesBefore > 1)
+    if (FirstTok->NewlinesBefore > 1)
       endUsingDeclarationBlock(&UsingDeclarations, SourceMgr, &Fixes);
-    std::string Label = computeUsingDeclarationLabel(AnnotatedLines[I]->First);
+    const auto *UsingTok =
+        FirstTok->is(tok::comment) ? FirstTok->getNextNonComment() : FirstTok;
+    std::string Label = computeUsingDeclarationLabel(UsingTok);
     if (Label.empty()) {
       endUsingDeclarationBlock(&UsingDeclarations, SourceMgr, &Fixes);
       continue;
     }
     UsingDeclarations.push_back(UsingDeclaration(AnnotatedLines[I], Label));
   }
   endUsingDeclarationBlock(&UsingDeclarations, SourceMgr, &Fixes);
   return {Fixes, 0};
 }
 
 } // namespace format
 } // namespace clang

unittests/Format/UsingDeclarationsSorterTest.cpp

EXPECT_EQ("using d;\n"
                                   "using b;\n" // starts at offset 19
                                   "using a;\n"
                                   "\n"
                                   "using f;\n"
                                   "using e;",
                                   {tooling::Range(19, 1)}));
 }
 
+TEST_F(UsingDeclarationsSorterTest, SortsUsingDeclarationsWithLeadingkComments) {
+  EXPECT_EQ("/* comment */ using a;\n"
+            "/* comment */ using b;",
+            sortUsingDeclarations("/* comment */ using b;\n"
+                                  "/* comment */ using a;"));
+}
+
 } // end namespace
 } // end namespace format
 } // end namespace clang