[clang-format] Fix an assertion failure

[alexfh]

Summary

Before this patch clang-format crashed when trying to issue a diagnostic about an unsupported BOM. See the bug report here: https://bugs.llvm.org/show_bug.cgi?id=26032

clang/lib/Basic/SourceManager.cpp

SourceManagerForFile::SourceManagerForFile(StringRef FileName,
   // This is passed to `SM` as reference, so the pointer has to be referenced
   // in `Environment` so that `FileMgr` can out-live this function scope.
   FileMgr =
       llvm::make_unique<FileManager>(FileSystemOptions(), InMemoryFileSystem);
   // This is passed to `SM` as reference, so the pointer has to be referenced
   // by `Environment` due to the same reason above.
   Diagnostics = llvm::make_unique<DiagnosticsEngine>(
       IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs),
-      new DiagnosticOptions);
+      new DiagnosticOptions, new IgnoringDiagConsumer);
   SourceMgr = llvm::make_unique<SourceManager>(*Diagnostics, *FileMgr);
   FileID ID = SourceMgr->createFileID(FileMgr->getFile(FileName),
                                       SourceLocation(), clang::SrcMgr::C_User);
   assert(ID.isValid());
   SourceMgr->setMainFileID(ID);
 }

clang/lib/Format/Format.cpp

analyze(TokenAnnotator &Annotator,
     tooling::Replacements Result;
     deriveLocalStyle(AnnotatedLines);
     AffectedRangeMgr.computeAffectedLines(AnnotatedLines);
     for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
       Annotator.calculateFormattingInformation(*AnnotatedLines[i]);
     }
     Annotator.setCommentLineLevels(AnnotatedLines);
 
-    WhitespaceManager Whitespaces(
-        Env.getSourceManager(), Style,
-        inputUsesCRLF(Env.getSourceManager().getBufferData(Env.getFileID())));
+    WhitespaceManager Whitespaces(Env.getSourceManager(), Style,
+                                  inputUsesCRLF(Env.getBufferData()));
     ContinuationIndenter Indenter(Style, Tokens.getKeywords(),
                                   Env.getSourceManager(), Whitespaces, Encoding,
                                   BinPackInconclusiveFunctions);
     unsigned Penalty =
         UnwrappedLineFormatter(&Indenter, &Whitespaces, Style,
                                Tokens.getKeywords(), Env.getSourceManager(),
                                Status)
             .format(AnnotatedLines, /*DryRun=*/false,
if (Style.Language == FormatStyle::LK_JavaScript &&
     Passes.emplace_back([&](const Environment &Env) {
       return JavaScriptRequoter(Env, Expanded).process();
     });
 
   Passes.emplace_back([&](const Environment &Env) {
     return Formatter(Env, Expanded, Status).process();
   });
 
-  auto Env =
-      llvm::make_unique<Environment>(Code, FileName, Ranges, FirstStartColumn,
-                                     NextStartColumn, LastStartColumn);
+  auto Env = Environment::Create(Code, FileName, Ranges, FirstStartColumn,
+  if (!Env)
+    return {{}, 0};
   llvm::Optional<std::string> CurrentCode = None;
   tooling::Replacements Fixes;
   unsigned Penalty = 0;
   for (size_t I = 0, E = Passes.size(); I < E; ++I) {
     std::pair<tooling::Replacements, unsigned> PassFixes = Passes[I](*Env);
     auto NewCode = applyAllReplacements(
         CurrentCode ? StringRef(*CurrentCode) : Code, PassFixes.first);
     if (NewCode) {
       Fixes = Fixes.merge(PassFixes.first);
       Penalty += PassFixes.second;
       if (I + 1 < E) {
         CurrentCode = std::move(*NewCode);
-        Env = llvm::make_unique<Environment>(
+        Env = Environment::Create(
             *CurrentCode, FileName,
             tooling::calculateRangesAfterReplacements(Fixes, Ranges),
             FirstStartColumn, NextStartColumn, LastStartColumn);
+        if (!Env)
+          break;
       }
     }
   }
 
   return {Fixes, Penalty};
 }
 } // namespace internal
 
 tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
                                ArrayRef<tooling::Range> Ranges,
                                StringRef FileName,
                                FormattingAttemptStatus *Status) {
   return internal::reformat(Style, Code, Ranges,
                             /*FirstStartColumn=*/0,
                             /*NextStartColumn=*/0,
                             /*LastStartColumn=*/0, FileName, Status)
       .first;
 }
 
 tooling::Replacements cleanup(const FormatStyle &Style, StringRef Code,
                               ArrayRef<tooling::Range> Ranges,
                               StringRef FileName) {
   // cleanups only apply to C++ (they mostly concern ctor commas etc.)
   if (Style.Language != FormatStyle::LK_Cpp)
-    return tooling::Replacements();
-  return Cleaner(Environment(Code, FileName, Ranges), Style).process().first;
-}
+    return {};
+  if (auto Env = Environment::Create(Code, FileName, Ranges))
+    return Cleaner(*Env, Style).process().first; return {}; }
 
 tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
                                ArrayRef<tooling::Range> Ranges,
                                StringRef FileName, bool *IncompleteFormat) {
   FormattingAttemptStatus Status;
   auto Result = reformat(Style, Code, Ranges, FileName, &Status);
   if (!Status.FormatComplete)
     *IncompleteFormat = true;
   return Result;
 }
 
 tooling::Replacements fixNamespaceEndComments(const FormatStyle &Style,
                                               StringRef Code,
                                               ArrayRef<tooling::Range> Ranges,
                                               StringRef FileName) {
-  return NamespaceEndCommentsFixer(Environment(Code, FileName, Ranges), Style)
-      .process()
-      .first;
+  if (auto Env = Environment::Create(Code, FileName, Ranges))
+    return NamespaceEndCommentsFixer(*Env, Style).process().first;
+  return {};
 }
 
 tooling::Replacements sortUsingDeclarations(const FormatStyle &Style,
                                             StringRef Code,
                                             ArrayRef<tooling::Range> Ranges,
                                             StringRef FileName) {
-  return UsingDeclarationsSorter(Environment(Code, FileName, Ranges), Style)
-      .process()
-      .first;
+  if (auto Env = Environment::Create(Code, FileName, Ranges))
+    return UsingDeclarationsSorter(*Env, Style).process().first;
+  return {};
 }
 
 LangOptions getFormattingLangOpts(const FormatStyle &Style) {
   LangOptions LangOpts;
   LangOpts.CPlusPlus = 1;
   LangOpts.CPlusPlus11 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
   LangOpts.CPlusPlus14 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
   LangOpts.CPlusPlus17 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;

 FormatStyle::LanguageKind guessLanguage(StringRef FileName, StringRef Code) {
   const auto GuessedLanguage = getLanguageByFileName(FileName);
   if (GuessedLanguage == FormatStyle::LK_Cpp) {
     auto Extension = llvm::sys::path::extension(FileName);
     // If there's no file extension (or it's .h), we need to check the contents
     // of the code to see if it contains Objective-C.
     if (Extension.empty() || Extension == ".h") {
       auto NonEmptyFileName = FileName.empty() ? "guess.h" : FileName;
-      Environment Env(Code, NonEmptyFileName, /*Ranges=*/{});
-      ObjCHeaderStyleGuesser Guesser(Env, getLLVMStyle());
+      if (auto Env =
+              Environment::Create(Code, NonEmptyFileName, /*Ranges=*/{})) {
+        ObjCHeaderStyleGuesser Guesser(*Env, getLLVMStyle());
         Guesser.process();
         if (Guesser.isObjC())
           return FormatStyle::LK_ObjC;
       }
     }
+  }
   return GuessedLanguage;
 }
 
 const char *DefaultFormatStyle = "file";
 
 const char *DefaultFallbackStyle = "LLVM";
 
 llvm::Expected<FormatStyle> getStyle(StringRef StyleName, StringRef FileName,

clang/lib/Format/FormatTokenLexer.h

 enum LexerState {
   NORMAL,
   TEMPLATE_STRING,
   TOKEN_STASHED,
 };
 
 class FormatTokenLexer {
 public:
-  FormatTokenLexer(const SourceManager &SourceMgr, FileID ID, unsigned Column,
+  FormatTokenLexer(const SourceManager &SourceMgr, SourceLocation StartLoc,
+                   SourceLocation EndLoc, StringRef BufferData, unsigned Column,
                    const FormatStyle &Style, encoding::Encoding Encoding);
 
   ArrayRef<FormatToken *> lex();
 
   const AdditionalKeywords &getKeywords() { return Keywords; }
 
 private:
   void tryMergePreviousTokens();
private:
 
   FormatToken *FormatTok;
   bool IsFirstToken;
   std::stack<LexerState> StateStack;
   unsigned Column;
   unsigned TrailingWhitespace;
   std::unique_ptr<Lexer> Lex;
   const SourceManager &SourceMgr;
-  FileID ID;
+  SourceLocation StartLoc;
+  SourceLocation EndLoc;
+  StringRef BufferData;
   const FormatStyle &Style;
   IdentifierTable IdentTable;
   AdditionalKeywords Keywords;
   encoding::Encoding Encoding;
   llvm::SpecificBumpPtrAllocator<FormatToken> Allocator;
   // Index (in 'Tokens') of the last token that starts a new line.
   unsigned FirstInLineIndex;
   SmallVector<FormatToken *, 16> Tokens;

clang/lib/Format/FormatTokenLexer.cpp

 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Format/Format.h"
 #include "llvm/Support/Regex.h"
 
 namespace clang {
 namespace format {
 
-FormatTokenLexer::FormatTokenLexer(const SourceManager &SourceMgr, FileID ID,
+FormatTokenLexer::FormatTokenLexer(const SourceManager &SourceMgr,
+                                   SourceLocation StartLoc,
+                                   SourceLocation EndLoc, StringRef BufferData,
                                    unsigned Column, const FormatStyle &Style,
                                    encoding::Encoding Encoding)
     : FormatTok(nullptr), IsFirstToken(true), StateStack({LexerState::NORMAL}),
-      Column(Column), TrailingWhitespace(0), SourceMgr(SourceMgr), ID(ID),
-      Style(Style), IdentTable(getFormattingLangOpts(Style)),
-      Keywords(IdentTable), Encoding(Encoding), FirstInLineIndex(0),
-      FormattingDisabled(false), MacroBlockBeginRegex(Style.MacroBlockBegin),
+      Column(Column), TrailingWhitespace(0), SourceMgr(SourceMgr),
+      StartLoc(StartLoc), EndLoc(EndLoc), BufferData(BufferData), Style(Style),
+      IdentTable(getFormattingLangOpts(Style)), Keywords(IdentTable),
+      Encoding(Encoding), FirstInLineIndex(0), FormattingDisabled(false),
+      MacroBlockBeginRegex(Style.MacroBlockBegin),
       MacroBlockEndRegex(Style.MacroBlockEnd) {
-  Lex.reset(new Lexer(ID, SourceMgr.getBuffer(ID), SourceMgr,
-                      getFormattingLangOpts(Style)));
-  Lex->SetKeepWhitespaceMode(true);
+  resetLexer(0);
 
   for (const std::string &ForEachMacro : Style.ForEachMacros)
     Macros.insert({&IdentTable.get(ForEachMacro), TT_ForEachMacro});
   for (const std::string &StatementMacro : Style.StatementMacros)
     Macros.insert({&IdentTable.get(StatementMacro), TT_StatementMacro});
 }
 
 ArrayRef<FormatToken *> FormatTokenLexer::lex() {
if (LastBreak != StringRef::npos) {
     unsigned StartColumn = 0; // The template tail spans the entire line.
     BacktickToken->LastLineColumnWidth = encoding::columnWidthWithTabs(
         LiteralText.substr(LastBreak + 1, LiteralText.size()), StartColumn,
         Style.TabWidth, Encoding);
   }
 
   SourceLocation loc = Offset < Lex->getBuffer().end()
                            ? Lex->getSourceLocation(Offset + 1)
-                           : SourceMgr.getLocForEndOfFile(ID);
+                           : EndLoc;
   resetLexer(SourceMgr.getFileOffset(loc));
 }
 
 void FormatTokenLexer::tryParsePythonComment() {
   FormatToken *HashToken = Tokens.back();
   if (!HashToken->isOneOf(tok::hash, tok::hashhash))
     return;
   // Turn the remainder of this line into a comment.
   const char *CommentBegin =
       Lex->getBufferLocation() - HashToken->TokenText.size(); // at "#"
   size_t From = CommentBegin - Lex->getBuffer().begin();
   size_t To = Lex->getBuffer().find_first_of('\n', From);
   if (To == StringRef::npos)
     To = Lex->getBuffer().size();
   size_t Len = To - From;
   HashToken->Type = TT_LineComment;
   HashToken->Tok.setKind(tok::comment);
   HashToken->TokenText = Lex->getBuffer().substr(From, Len);
   SourceLocation Loc = To < Lex->getBuffer().size()
                            ? Lex->getSourceLocation(CommentBegin + Len)
-                           : SourceMgr.getLocForEndOfFile(ID);
+                           : EndLoc;
   resetLexer(SourceMgr.getFileOffset(Loc));
 }
 
 bool FormatTokenLexer::tryMerge_TMacro() {
   if (Tokens.size() < 4)
     return false;
   FormatToken *Last = Tokens.back();
   if (!Last->is(tok::r_paren))
void FormatTokenLexer::readRawToken(FormatToken &Tok) {
 
   if (Tok.is(tok::comment) && (Tok.TokenText == "// clang-format off" ||
                                Tok.TokenText == "/* clang-format off */")) {
     FormattingDisabled = true;
   }
 }
 
 void FormatTokenLexer::resetLexer(unsigned Offset) {
-  StringRef Buffer = SourceMgr.getBufferData(ID);
-  Lex.reset(new Lexer(SourceMgr.getLocForStartOfFile(ID),
-                      getFormattingLangOpts(Style), Buffer.begin(),
-                      Buffer.begin() + Offset, Buffer.end()));
+  Lex = llvm::make_unique<Lexer>(StartLoc, getFormattingLangOpts(Style),
+                                 BufferData.begin(),
+                                 BufferData.begin() + Offset, BufferData.end());
   Lex->SetKeepWhitespaceMode(true);
   TrailingWhitespace = 0;
 }
 
 } // namespace format
 } // namespace clang

clang/lib/Format/SortJavaScriptImports.cpp

 }
 
 // JavaScriptImportSorter sorts JavaScript ES6 imports and exports. It is
 // implemented as a TokenAnalyzer because ES6 imports have substantial syntactic
 // structure, making it messy to sort them using regular expressions.
 class JavaScriptImportSorter : public TokenAnalyzer {
 public:
   JavaScriptImportSorter(const Environment &Env, const FormatStyle &Style)
-      : TokenAnalyzer(Env, Style),
-        FileContents(Env.getSourceManager().getBufferData(Env.getFileID())) {}
+      : TokenAnalyzer(Env, Style), FileContents(Env.getBufferData()) {}
 
   std::pair<tooling::Replacements, unsigned>
   analyze(TokenAnnotator &Annotator,
           SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
           FormatTokenLexer &Tokens) override {
     tooling::Replacements Result;
     AffectedRangeMgr.computeAffectedLines(AnnotatedLines);
 
bool parseNamedBindings(const AdditionalKeywords &Keywords,
     return true;
   }
 };
 
 tooling::Replacements sortJavaScriptImports(const FormatStyle &Style,
                                             StringRef Code,
                                             ArrayRef<tooling::Range> Ranges,
                                             StringRef FileName) {
+  if (auto Env = Environment::Create(Code, FileName, Ranges)) {
     // FIXME: Cursor support.
-  return JavaScriptImportSorter(Environment(Code, FileName, Ranges), Style)
-      .process()
-      .first;
+    return JavaScriptImportSorter(*Env, Style).process().first;
+  }
+  return {};
 }
 
 } // end namespace format
 } // end namespace clang

clang/lib/Format/TokenAnalyzer.h

 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Debug.h"
 
 namespace clang {
 namespace format {
 
 class Environment {
 public:
-  // This sets up an virtual file system with file \p FileName containing the
-  // fragment \p Code. Assumes that \p Code starts at \p FirstStartColumn,
-  // that the next lines of \p Code should start at \p NextStartColumn, and
-  // that \p Code should end at \p LastStartColumn if it ends in newline.
-  // See also the documentation of clang::format::internal::reformat.
-  Environment(StringRef Code, StringRef FileName,
-              ArrayRef<tooling::Range> Ranges, unsigned FirstStartColumn = 0,
-              unsigned NextStartColumn = 0, unsigned LastStartColumn = 0);
-
-  FileID getFileID() const { return ID; }
+  static std::unique_ptr<Environment> Create(StringRef Code, StringRef FileName,
+                                             ArrayRef<tooling::Range> Ranges,
+                                             unsigned FirstStartColumn = 0,
+                                             unsigned NextStartColumn = 0,
+                                             unsigned LastStartColumn = 0);
 
   const SourceManager &getSourceManager() const { return SM; }
 
+  StringRef getBufferData() const { return BufferData; }
+  SourceLocation getStartLoc() const { return SM.getLocForStartOfFile(ID); }
+  SourceLocation getEndLoc() const { return SM.getLocForEndOfFile(ID); }
+
   ArrayRef<CharSourceRange> getCharRanges() const { return CharRanges; }
 
   // Returns the column at which the fragment of code managed by this
   // environment starts.
   unsigned getFirstStartColumn() const { return FirstStartColumn; }
 
   // Returns the column at which subsequent lines of the fragment of code
   // managed by this environment should start.
   unsigned getNextStartColumn() const { return NextStartColumn; }
 
   // Returns the column at which the fragment of code managed by this
   // environment should end if it ends in a newline.
   unsigned getLastStartColumn() const { return LastStartColumn; }
 
 private:
+  // This sets up an virtual file system with file \p FileName containing the
+  // fragment \p Code. Assumes that \p Code starts at \p FirstStartColumn,
+  // that the next lines of \p Code should start at \p NextStartColumn, and
+  // that \p Code should end at \p LastStartColumn if it ends in newline.
+  // See also the documentation of clang::format::internal::reformat.
+  Environment(StringRef Code, StringRef FileName,
+              ArrayRef<tooling::Range> Ranges, unsigned FirstStartColumn,
+              unsigned NextStartColumn, unsigned LastStartColumn,
+              bool *InvalidBuffer);
+
   // This is only set if constructed from string.
   std::unique_ptr<SourceManagerForFile> VirtualSM;
 
   // This refers to either a SourceManager provided by users or VirtualSM
   // created for a single file.
   SourceManager &SM;
   FileID ID;
 
   SmallVector<CharSourceRange, 8> CharRanges;
   unsigned FirstStartColumn;
   unsigned NextStartColumn;
   unsigned LastStartColumn;
+  StringRef BufferData;
 };
 
 class TokenAnalyzer : public UnwrappedLineConsumer {
 public:
   TokenAnalyzer(const Environment &Env, const FormatStyle &Style);
 
   std::pair<tooling::Replacements, unsigned> process();
 

clang/lib/Format/TokenAnalyzer.cpp

 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Debug.h"
 
 #define DEBUG_TYPE "format-formatter"
 
 namespace clang {
 namespace format {
 
+std::unique_ptr<Environment>
+Environment::Create(StringRef Code, StringRef FileName,
+                    ArrayRef<tooling::Range> Ranges, unsigned FirstStartColumn,
+                    unsigned NextStartColumn, unsigned LastStartColumn) {
+  bool InvalidBuffer = true;
+  std::unique_ptr<Environment> Env(
+      new Environment(Code, FileName, Ranges, FirstStartColumn, NextStartColumn,
+                      LastStartColumn, &InvalidBuffer));
+  if (InvalidBuffer)
+    return nullptr;
+  return Env;
+}
+
 Environment::Environment(StringRef Code, StringRef FileName,
                          ArrayRef<tooling::Range> Ranges,
                          unsigned FirstStartColumn, unsigned NextStartColumn,
-                         unsigned LastStartColumn)
+                         unsigned LastStartColumn, bool *InvalidBuffer)
     : VirtualSM(new SourceManagerForFile(FileName, Code)), SM(VirtualSM->get()),
       ID(VirtualSM->get().getMainFileID()), FirstStartColumn(FirstStartColumn),
       NextStartColumn(NextStartColumn), LastStartColumn(LastStartColumn) {
+  BufferData = SM.getBufferData(ID, InvalidBuffer);
+  if (*InvalidBuffer)
+    return;
   SourceLocation StartOfFile = SM.getLocForStartOfFile(ID);
   for (const tooling::Range &Range : Ranges) {
     SourceLocation Start = StartOfFile.getLocWithOffset(Range.getOffset());
     SourceLocation End = Start.getLocWithOffset(Range.getLength());
     CharRanges.push_back(CharSourceRange::getCharRange(Start, End));
   }
 }
 
 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()))) {
+      Encoding(encoding::detectEncoding(Env.getBufferData())) {
   LLVM_DEBUG(
       llvm::dbgs() << "File encoding: "
                    << (Encoding == encoding::Encoding_UTF8 ? "UTF8" : "unknown")
                    << "\n");
   LLVM_DEBUG(llvm::dbgs() << "Language: " << getLanguageName(Style.Language)
                           << "\n");
 }
 
 std::pair<tooling::Replacements, unsigned> TokenAnalyzer::process() {
   tooling::Replacements Result;
-  FormatTokenLexer Tokens(Env.getSourceManager(), Env.getFileID(),
+  FormatTokenLexer Tokens(Env.getSourceManager(), Env.getStartLoc(),
+                          Env.getEndLoc(), Env.getBufferData(),
                           Env.getFirstStartColumn(), Style, Encoding);
 
   UnwrappedLineParser Parser(Style, Tokens.getKeywords(),
                              Env.getFirstStartColumn(), Tokens.lex(), *this);
   Parser.parse();
   assert(UnwrappedLines.rbegin()->empty());
   unsigned Penalty = 0;
   for (unsigned Run = 0, RunE = UnwrappedLines.size(); Run + 1 != RunE; ++Run) {

clang/test/Format/invalid-bom.cpp

+// REQUIRES: shell
+// RUN: echo -en "\xff\xfeinput with invalid BOM" | clang-format - >%t.out
+// RUN: grep "input with invalid BOM" %t.out

clang/tools/clang-format/ClangFormat.cpp

llvm::Expected<FormatStyle> FormatStyle =
       getStyle(Style, AssumedFileName, FallbackStyle, Code->getBuffer());
   if (!FormatStyle) {
     llvm::errs() << llvm::toString(FormatStyle.takeError()) << "\n";
     return true;
   }
 
   if (SortIncludes.getNumOccurrences() != 0)
     FormatStyle->SortIncludes = SortIncludes;
+
   unsigned CursorPosition = Cursor;
   Replacements Replaces = sortIncludes(*FormatStyle, Code->getBuffer(), Ranges,
                                        AssumedFileName, &CursorPosition);
   auto ChangedCode = tooling::applyAllReplacements(Code->getBuffer(), Replaces);
   if (!ChangedCode) {
     llvm::errs() << llvm::toString(ChangedCode.takeError()) << "\n";
     return true;
   }
if (OutputXML) {
     outs() << ">\n";
     if (Cursor.getNumOccurrences() != 0)
       outs() << "<cursor>"
              << FormatChanges.getShiftedCodePosition(CursorPosition)
              << "</cursor>\n";
 
     outputReplacementsXML(Replaces);
     outs() << "</replacements>\n";
-  } else {
+  } else if (!Replaces.empty()) {
     IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFileSystem(
         new llvm::vfs::InMemoryFileSystem);
     FileManager Files(FileSystemOptions(), InMemoryFileSystem);
     DiagnosticsEngine Diagnostics(
         IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs),
-        new DiagnosticOptions);
+        new DiagnosticOptions, new IgnoringDiagConsumer);
     SourceManager Sources(Diagnostics, Files);
     FileID ID = createInMemoryFile(AssumedFileName, Code.get(), Sources, Files,
                                    InMemoryFileSystem.get());
     Rewriter Rewrite(Sources, LangOptions());
     tooling::applyAllReplacements(Replaces, Rewrite);
     if (Inplace) {
       if (Rewrite.overwriteChangedFiles())
         return true;
     } else {
       if (Cursor.getNumOccurrences() != 0) {
         outs() << "{ \"Cursor\": "
                << FormatChanges.getShiftedCodePosition(CursorPosition)
                << ", \"IncompleteFormat\": "
                << (Status.FormatComplete ? "false" : "true");
         if (!Status.FormatComplete)
           outs() << ", \"Line\": " << Status.Line;
         outs() << " }\n";
       }
       Rewrite.getEditBuffer(ID).write(outs());
     }
+  } else if (!Inplace) { // Nothing changed, but we still need to dump the input
+                         // as is.
+    outs() << Code->getBuffer();
   }
   return false;
 }
 
 }  // namespace format
 }  // namespace clang
 
 static void PrintVersion(raw_ostream &OS) {