[clang-format] NFC - recent changes caused clang-format to no longer be clang-formatted.

[MyDeveloperDay]

Summary

The following 2 commits caused files in clang-format to no longer be clang-formatted.

we would lose our "clean" status https://releases.llvm.org/13.0.0/tools/clang/docs/ClangFormattedStatus.html

c2271926a4fc - Make clang-format fuzz through Lexing with asserts enabled (https://github.com/llvm/llvm-project/commit/c2271926a4fc )

84bf5e328664 - Fix various problems found by fuzzing. (https://github.com/llvm/llvm-project/commit/84bf5e328664)

[klimek]

Thanks for cleaning up after me, and sorry for the mess - do y'all have clang-format set up as a presubmit or do you just remember to format manually?

[MyDeveloperDay]

In D114430#3151082, @klimek wrote:

Thanks for cleaning up after me, and sorry for the mess - do y'all have clang-format set up as a presubmit or do you just remember to format manually?

Its never a problem to clean up after you of all people, happy to do so.

I personally "Format on Save", but my "phabricator patch creation" does a "git clang-format" too.

[HazardyKnusperkeks]

In D114430#3151082, @klimek wrote:

Thanks for cleaning up after me, and sorry for the mess - do y'all have clang-format set up as a presubmit or do you just remember to format manually?

I think one "problem" is that it did not go through review, otherwise the there were notes in the review. ;)
I use QtCreator with its clang-format integration and the changed lines get formatted as soon as I press ; or }. Additionally I can format the current line(s).

[owenpan]

In D114430#3152609, @HazardyKnusperkeks wrote:

In D114430#3151082, @klimek wrote:

Thanks for cleaning up after me, and sorry for the mess - do y'all have clang-format set up as a presubmit or do you just remember to format manually?

I think one "problem" is that it did not go through review, otherwise the there were notes in the review. ;)

+1

clang/lib/Format/Format.cpp

reformat(const FormatStyle &Style, StringRef Code,
   if (isLikelyXml(Code))
     return {tooling::Replacements(), 0};
   if (Expanded.Language == FormatStyle::LK_JavaScript && isMpegTS(Code))
     return {tooling::Replacements(), 0};
 
   // JSON only needs the formatting passing.
   if (Style.isJson()) {
     std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size()));
-    auto Env =
-        Environment::make(Code, FileName, Ranges, FirstStartColumn,
-                                      NextStartColumn, LastStartColumn);
+    auto Env = Environment::make(Code, FileName, Ranges, FirstStartColumn,
     if (!Env)
       return {};
     // Perform the actual formatting pass.
     tooling::Replacements Replaces =
         Formatter(*Env, Style, Status).process().first;
     // add a replacement to remove the "x = " from the result.
     if (!Replaces.add(tooling::Replacement(FileName, 0, 4, ""))) {
       // apply the reformatting changes and the removal of "x = ".

 
 tooling::Replacements fixNamespaceEndComments(const FormatStyle &Style,
                                               StringRef Code,
                                               ArrayRef<tooling::Range> Ranges,
                                               StringRef FileName) {
   auto Env = Environment::make(Code, FileName, Ranges);
   if (!Env)
     return {};
-  return NamespaceEndCommentsFixer(*Env, Style)
-      .process()
-      .first;
+  return NamespaceEndCommentsFixer(*Env, Style).process().first;
 }
 
 tooling::Replacements sortUsingDeclarations(const FormatStyle &Style,
                                             StringRef Code,
                                             ArrayRef<tooling::Range> Ranges,
                                             StringRef FileName) {
   auto Env = Environment::make(Code, FileName, Ranges);
   if (!Env)
     return {};
-  return UsingDeclarationsSorter(*Env, Style)
-      .process()
-      .first;
+  return UsingDeclarationsSorter(*Env, Style).process().first;
 }
 
 LangOptions getFormattingLangOpts(const FormatStyle &Style) {
   LangOptions LangOpts;
 
   FormatStyle::LanguageStandard LexingStd = Style.Standard;
   if (LexingStd == FormatStyle::LS_Auto)
     LexingStd = FormatStyle::LS_Latest;

clang/lib/Format/SortJavaScriptImports.cpp

 tooling::Replacements sortJavaScriptImports(const FormatStyle &Style,
                                             StringRef Code,
                                             ArrayRef<tooling::Range> Ranges,
                                             StringRef FileName) {
   // FIXME: Cursor support.
   auto Env = Environment::make(Code, FileName, Ranges);
   if (!Env)
     return {};
-  return JavaScriptImportSorter(*Env, Style)
-      .process()
-      .first;
+  return JavaScriptImportSorter(*Env, Style).process().first;
 }
 
 } // end namespace format
 } // end namespace clang

clang/lib/Format/TokenAnalyzer.cpp

 
 #define DEBUG_TYPE "format-formatter"
 
 namespace clang {
 namespace format {
 
 // FIXME: Instead of printing the diagnostic we should store it and have a
 // better way to return errors through the format APIs.
-class FatalDiagnosticConsumer: public DiagnosticConsumer {
+class FatalDiagnosticConsumer : public DiagnosticConsumer {
 public:
   void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
                         const Diagnostic &Info) override {
     if (DiagLevel == DiagnosticsEngine::Fatal) {
       Fatal = true;
       llvm::SmallVector<char, 128> Message;
       Info.FormatDiagnostic(Message);
       llvm::errs() << Message << "\n";
Environment::make(StringRef Code, StringRef FileName,
   SourceLocation StartOfFile = Env->SM.getLocForStartOfFile(Env->ID);
   for (const tooling::Range &Range : Ranges) {
     SourceLocation Start = StartOfFile.getLocWithOffset(Range.getOffset());
     SourceLocation End = Start.getLocWithOffset(Range.getLength());
     Env->CharRanges.push_back(CharSourceRange::getCharRange(Start, End));
   }
   // Validate that we can get the buffer data without a fatal error.
   Env->SM.getBufferData(Env->ID);
-  if (Diags.fatalError()) return nullptr;
+  if (Diags.fatalError())
+    return nullptr;
   return Env;
 }
 
 Environment::Environment(StringRef Code, StringRef FileName,
                          unsigned FirstStartColumn, unsigned NextStartColumn,
                          unsigned LastStartColumn)
     : VirtualSM(new SourceManagerForFile(FileName, Code)), SM(VirtualSM->get()),
       ID(VirtualSM->get().getMainFileID()), FirstStartColumn(FirstStartColumn),
-      NextStartColumn(NextStartColumn), LastStartColumn(LastStartColumn) {
-}
+      NextStartColumn(NextStartColumn), LastStartColumn(LastStartColumn) {}
 
 TokenAnalyzer::TokenAnalyzer(const Environment &Env, const FormatStyle &Style)
     : Style(Style), Env(Env),
       AffectedRangeMgr(Env.getSourceManager(), Env.getCharRanges()),
       UnwrappedLines(1),
       Encoding(encoding::detectEncoding(
           Env.getSourceManager().getBufferData(Env.getFileID()))) {
   LLVM_DEBUG(

clang/lib/Format/TokenAnnotator.cpp

for (const FormatToken *Tok = AL->First; Tok; Tok = Tok->Next) {
       }
     }
 
     // If the comment is currently aligned with the line immediately following
     // it, that's probably intentional and we should keep it.
     if (NextNonCommentLine && CommentLine &&
         NextNonCommentLine->First->NewlinesBefore <= 1 &&
         NextNonCommentLine->First->OriginalColumn ==
             AL->First->OriginalColumn) {
       // Align comments for preprocessor lines with the # in column 0 if
       // preprocessor lines are not indented. Otherwise, align with the next
       // line.
-      AL->Level =
-          (Style.IndentPPDirectives != FormatStyle::PPDIS_BeforeHash &&
+      AL->Level = (Style.IndentPPDirectives != FormatStyle::PPDIS_BeforeHash &&
                    (NextNonCommentLine->Type == LT_PreprocessorDirective ||
                     NextNonCommentLine->Type == LT_ImportStatement))
                       ? 0
                       : NextNonCommentLine->Level;
     } else {
       NextNonCommentLine = AL->First->isNot(tok::r_brace) ? AL : nullptr;
     }
 
     setCommentLineLevels(AL->Children);
   }
 }
 

clang/lib/Format/WhitespaceManager.cpp

for (unsigned i = Start; i != End; ++i) {
     if (Changes[i].IsTrailingComment) {
       Shift = Column - Changes[i].StartOfTokenColumn;
     }
     if (Changes[i].StartOfBlockComment) {
       Shift = Changes[i].IndentationOffset +
               Changes[i].StartOfBlockComment->StartOfTokenColumn -
               Changes[i].StartOfTokenColumn;
     }
-    if (Shift < 0) continue;
+    if (Shift < 0)
+      continue;
     Changes[i].Spaces += Shift;
     if (i + 1 != Changes.size())
       Changes[i + 1].PreviousEndOfTokenColumn += Shift;
     Changes[i].StartOfTokenColumn += Shift;
   }
 }
 
 void WhitespaceManager::alignEscapedNewlines() {
WhitespaceManager::linkCells(CellDescriptions &&CellDesc) {
   }
   return std::move(CellDesc);
 }
 
 void WhitespaceManager::generateChanges() {
   for (unsigned i = 0, e = Changes.size(); i != e; ++i) {
     const Change &C = Changes[i];
     if (i > 0 && Changes[i - 1].OriginalWhitespaceRange.getBegin() ==
                      C.OriginalWhitespaceRange.getBegin()) {
       // Do not generate two replacements for the same location.
       continue;
     }
     if (C.CreateReplacement) {
       std::string ReplacementText = C.PreviousLinePostfix;
       if (C.ContinuesPPDirective)
         appendEscapedNewlineText(ReplacementText, C.NewlinesBefore,
                                  C.PreviousEndOfTokenColumn,