[clang-tidy] Add --fix-mode and --nolint-prefix options

[KyleFromKitware]

Fixed crash when warning doesn't have associated location.

[KyleFromKitware]

Added tests and fixed assertion error in release build.

[KyleFromKitware]

Rebased onto D143099.

[KyleFromKitware]

I just tried this out on a somewhat larger scale - I built all of CMake with this flag enabled, and it found a number of clang-tidy violations and added NOLINT comments to silence them. Worked like a charm.

[KyleFromKitware]

Though I did find that it inserted more than one NOLINT comment for a templated function, probably due to multiple warnings being issued for the same violation.

[gribozavr2]

clang-tools-extra/clang-tidy/ClangTidyDiagnosticConsumer.cpp

58

Note that if the NOLINT is being inserted into a macro definition, we also need a backslash before the newline.

clang-tools-extra/clang-tidy/ClangTidyDiagnosticConsumer.h

245

Generally in Clang and adjacent projects we reserve the word "Type" to refer to C++ types. For other uses, we use a synonym - like "Kind" or "Mode".

I think "FixMode" will work well here, WDYT?

251

I think it would be better to use an enum class and avoid prefixing.

(There are a lot of plain enums in Clang because Clang was originally developed in C++03.)

clang-tools-extra/test/clang-tidy/infrastructure/fix-mode-nolint.cpp

2 ↗

(On Diff #494031)

Could you add a second clang-tidy invocation over the fixed file to show that no warnings are produced? That would prove that the comments are inserted in the right place.

(here and in the other test)

7 ↗

(On Diff #494031)

WDYT about making the comment style configurable? I think many people working in C++ will prefer //-style comments.

18 ↗

(On Diff #494031)

Could you add more tests, specifically tests with macros?

• A test where the problem is reported in the macro expansion, the warning is attached to the macro definition.

• A test where the problem is reported in the macro expansion, but the warning is attached to the tokens in the macro argument.

The SourceLocation computations are quite subtle with macros so these cases are worth covering.

Note that when inserting NOLINTs into a macro definition, one has to use /* */-style comments.

clang-tools-extra/clang-tidy/ClangTidy.h

 /// \param StoreCheckProfile If provided, and EnableCheckProfile is true,
 /// the profile will not be output to stderr, but will instead be stored
 /// as a JSON file in the specified directory.
 std::vector<ClangTidyError>
 runClangTidy(clang::tidy::ClangTidyContext &Context,
              const tooling::CompilationDatabase &Compilations,
              ArrayRef<std::string> InputFiles,
              llvm::IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem> BaseFS,
-             bool ApplyAnyFix, bool EnableCheckProfile = false,
+             bool ApplyAnyFix, FixType Type, StringRef NoLintPrefix,
+             bool EnableCheckProfile = false,
              llvm::StringRef StoreCheckProfile = StringRef());
 
 /// Controls what kind of fixes clang-tidy is allowed to apply.
 enum FixBehaviour {
   /// Don't try to apply any fix.
   FB_NoFix,
   /// Only apply fixes added to warnings.
   FB_Fix,
   /// Apply fixes found in notes.
   FB_FixNotes
 };
 
 // FIXME: This interface will need to be significantly extended to be useful.
 // FIXME: Implement confidence levels for displaying/fixing errors.
 //
 /// Displays the found \p Errors to the users. If \p Fix is \ref FB_Fix or \ref
 /// FB_FixNotes, \p Errors containing fixes are automatically applied and
 /// reformatted. If no clang-format configuration file is found, the given \P
 /// FormatStyle is used.
 void handleErrors(llvm::ArrayRef<ClangTidyError> Errors,
-                  ClangTidyContext &Context, FixBehaviour Fix,
+                  ClangTidyContext &Context, FixBehaviour Fix, FixType Type,
                   unsigned &WarningsAsErrorsCount,
                   llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> BaseFS);
 
 /// Serializes replacements into YAML and writes them to the specified
 /// output stream.
 void exportReplacements(StringRef MainFilePath,
                         const std::vector<ClangTidyError> &Errors,
-                        raw_ostream &OS);
+                        raw_ostream &OS, FixType Type);
 
 } // end namespace tidy
 } // end namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDY_H

clang-tools-extra/clang-tidy/ClangTidy.cpp

 #include "clang/Rewrite/Frontend/FrontendActions.h"
 #include "clang/Tooling/Core/Diagnostic.h"
 #include "clang/Tooling/DiagnosticsYaml.h"
 #include "clang/Tooling/Refactoring.h"
 #include "clang/Tooling/ReplacementsYaml.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/Support/Process.h"
 #include <algorithm>
+#include <tuple>
 #include <utility>
 
 #if CLANG_TIDY_ENABLE_STATIC_ANALYZER
 #include "clang/Analysis/PathDiagnostic.h"
 #include "clang/StaticAnalyzer/Frontend/AnalysisConsumer.h"
 #endif // CLANG_TIDY_ENABLE_STATIC_ANALYZER
 
 using namespace clang::ast_matchers;

 private:
   ClangTidyContext &Context;
 };
 #endif // CLANG_TIDY_ENABLE_STATIC_ANALYZER
 
 class ErrorReporter {
 public:
   ErrorReporter(ClangTidyContext &Context, FixBehaviour ApplyFixes,
+                FixType Type,
                 llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> BaseFS)
       : Files(FileSystemOptions(), std::move(BaseFS)),
         DiagOpts(new DiagnosticOptions()),
         DiagPrinter(new TextDiagnosticPrinter(llvm::outs(), &*DiagOpts)),
         Diags(IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs), &*DiagOpts,
               DiagPrinter),
         SourceMgr(Diags, Files), Context(Context), ApplyFixes(ApplyFixes),
-        TotalFixes(0), AppliedFixes(0), WarningsAsErrors(0) {
+        Type(Type), TotalFixes(0), AppliedFixes(0), WarningsAsErrors(0) {
     DiagOpts->ShowColors = Context.getOptions().UseColor.value_or(
         llvm::sys::Process::StandardOutHasColors());
     DiagPrinter->BeginSourceFile(LangOpts);
     if (DiagOpts->ShowColors && !llvm::sys::Process::StandardOutIsDisplayed()) {
       llvm::sys::Process::UseANSIEscapeCodes(true);
     }
   }
 
   SourceManager &getSourceManager() { return SourceMgr; }
 
   void reportDiagnostic(const ClangTidyError &Error) {
     const tooling::DiagnosticMessage &Message = Error.Message;
     SourceLocation Loc = getLocation(Message.FilePath, Message.FileOffset);
     // Contains a pair for each attempted fix: location and whether the fix was
     // applied successfully.
-    SmallVector<std::pair<SourceLocation, bool>, 4> FixLocations;
+    SmallVector<std::tuple<SourceLocation, FixType, bool>, 4> FixLocations;
     {
       auto Level = static_cast<DiagnosticsEngine::Level>(Error.DiagLevel);
       std::string Name = Error.DiagnosticName;
       if (!Error.EnabledDiagnosticAliases.empty())
         Name += "," + llvm::join(Error.EnabledDiagnosticAliases, ",");
       if (Error.IsWarningAsError) {
         Name += ",-warnings-as-errors";
         Level = DiagnosticsEngine::Error;
         WarningsAsErrors++;
       }
       auto Diag = Diags.Report(Loc, Diags.getCustomDiagID(Level, "%0 [%1]"))
                   << Message.Message << Name;
       for (const FileByteRange &FBR : Error.Message.Ranges)
         Diag << getRange(FBR);
       // FIXME: explore options to support interactive fix selection.
-      const llvm::StringMap<Replacements> *ChosenFix;
+      std::pair<const llvm::StringMap<Replacements> *, FixType> ChosenFix;
       if (ApplyFixes != FB_NoFix &&
-          (ChosenFix = getFixIt(Error, ApplyFixes == FB_FixNotes))) {
-        for (const auto &FileAndReplacements : *ChosenFix) {
+          std::get<0>(ChosenFix =
+                          getFixIt(Error, Type, ApplyFixes == FB_FixNotes))) {
+        for (const auto &FileAndReplacements : *std::get<0>(ChosenFix)) {
           for (const auto &Repl : FileAndReplacements.second) {
             ++TotalFixes;
             bool CanBeApplied = false;
             if (!Repl.isApplicable())
               continue;
             SourceLocation FixLoc;
             SmallString<128> FixAbsoluteFilePath = Repl.getFilePath();
             Files.makeAbsolutePath(FixAbsoluteFilePath);
SmallVector<std::tuple<SourceLocation, FixType, bool>, 4> FixLocations;
                 llvm::errs()
                     << "Can't resolve conflict, skipping the replacement.\n";
               }
             } else {
               CanBeApplied = true;
               ++AppliedFixes;
             }
             FixLoc = getLocation(FixAbsoluteFilePath, Repl.getOffset());
-            FixLocations.push_back(std::make_pair(FixLoc, CanBeApplied));
+            FixLocations.emplace_back(FixLoc, std::get<1>(ChosenFix),
+                                      CanBeApplied);
           }
         }
       }
       reportFix(Diag, Error.Message.Fix);
     }
     for (auto Fix : FixLocations) {
-      Diags.Report(Fix.first, Fix.second ? diag::note_fixit_applied
+      Diags.Report(std::get<0>(Fix), std::get<2>(Fix)
+                                         ? (std::get<1>(Fix) == FT_FixIt
+                                                ? diag::note_fixit_applied
+                                                : diag::note_fixit_added_nolint)
                                          : diag::note_fixit_failed);
     }
     for (const auto &Note : Error.Notes)
       reportNote(Note);
   }
 
   void finish() {
     if (TotalFixes > 0) {
private:
   LangOptions LangOpts; // FIXME: use langopts from each original file
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts;
   DiagnosticConsumer *DiagPrinter;
   DiagnosticsEngine Diags;
   SourceManager SourceMgr;
   llvm::StringMap<Replacements> FileReplacements;
   ClangTidyContext &Context;
   FixBehaviour ApplyFixes;
+  FixType Type;
   unsigned TotalFixes;
   unsigned AppliedFixes;
   unsigned WarningsAsErrors;
 };
 
 class ClangTidyASTConsumer : public MultiplexConsumer {
 public:
   ClangTidyASTConsumer(std::vector<std::unique_ptr<ASTConsumer>> Consumers,
getCheckOptions(const ClangTidyOptions &Options,
   return Factory.getCheckOptions();
 }
 
 std::vector<ClangTidyError>
 runClangTidy(clang::tidy::ClangTidyContext &Context,
              const CompilationDatabase &Compilations,
              ArrayRef<std::string> InputFiles,
              llvm::IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem> BaseFS,
-             bool ApplyAnyFix, bool EnableCheckProfile,
-             llvm::StringRef StoreCheckProfile) {
+             bool ApplyAnyFix, FixType Type, StringRef NoLintPrefix,
+             bool EnableCheckProfile, llvm::StringRef StoreCheckProfile) {
   ClangTool Tool(Compilations, InputFiles,
                  std::make_shared<PCHContainerOperations>(), BaseFS);
 
   // Add extra arguments passed by the clang-tidy command-line.
   ArgumentsAdjuster PerFileExtraArgumentsInserter =
       [&Context](const CommandLineArguments &Args, StringRef Filename) {
         ClangTidyOptions Opts = Context.getOptionsForFile(Filename);
         CommandLineArguments AdjustedArgs = Args;
ArgumentsAdjuster PerFileExtraArgumentsInserter =
         return AdjustedArgs;
       };
 
   Tool.appendArgumentsAdjuster(PerFileExtraArgumentsInserter);
   Tool.appendArgumentsAdjuster(getStripPluginsAdjuster());
   Context.setEnableProfiling(EnableCheckProfile);
   Context.setProfileStoragePrefix(StoreCheckProfile);
 
-  ClangTidyDiagnosticConsumer DiagConsumer(Context, nullptr, true, ApplyAnyFix);
+  ClangTidyDiagnosticConsumer DiagConsumer(Context, nullptr, true, ApplyAnyFix,
+                                           Type, NoLintPrefix);
   DiagnosticsEngine DE(new DiagnosticIDs(), new DiagnosticOptions(),
                        &DiagConsumer, /*ShouldOwnClient=*/false);
   Context.setDiagnosticsEngine(&DE);
   Tool.setDiagnosticConsumer(&DiagConsumer);
 
   class ActionFactory : public FrontendActionFactory {
   public:
     ActionFactory(ClangTidyContext &Context,
runClangTidy(clang::tidy::ClangTidyContext &Context,
   };
 
   ActionFactory Factory(Context, std::move(BaseFS));
   Tool.run(&Factory);
   return DiagConsumer.take();
 }
 
 void handleErrors(llvm::ArrayRef<ClangTidyError> Errors,
-                  ClangTidyContext &Context, FixBehaviour Fix,
+                  ClangTidyContext &Context, FixBehaviour Fix, FixType Type,
                   unsigned &WarningsAsErrorsCount,
                   llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> BaseFS) {
-  ErrorReporter Reporter(Context, Fix, std::move(BaseFS));
+  ErrorReporter Reporter(Context, Fix, Type, std::move(BaseFS));
   llvm::vfs::FileSystem &FileSystem =
       Reporter.getSourceManager().getFileManager().getVirtualFileSystem();
   auto InitialWorkingDir = FileSystem.getCurrentWorkingDirectory();
   if (!InitialWorkingDir)
     llvm::report_fatal_error("Cannot get current working path.");
 
   for (const ClangTidyError &Error : Errors) {
     if (!Error.BuildDirectory.empty()) {
       // By default, the working directory of file system is the current
       // clang-tidy running directory.
       //
       // Change the directory to the one used during the analysis.
       FileSystem.setCurrentWorkingDirectory(Error.BuildDirectory);
     }
     Reporter.reportDiagnostic(Error);
     // Return to the initial directory to correctly resolve next Error.
     FileSystem.setCurrentWorkingDirectory(InitialWorkingDir.get());
   }
   Reporter.finish();
   WarningsAsErrorsCount += Reporter.getWarningsAsErrorsCount();
 }
 
 void exportReplacements(const llvm::StringRef MainFilePath,
                         const std::vector<ClangTidyError> &Errors,
-                        raw_ostream &OS) {
+                        raw_ostream &OS, FixType Type) {
   TranslationUnitDiagnostics TUD;
   TUD.MainSourceFile = std::string(MainFilePath);
   for (const auto &Error : Errors) {
     tooling::Diagnostic Diag = Error;
+    if (Type == FT_NoLint ||
+        (Type == FT_FixItOrNoLint && Error.Message.Fix.empty()))
+      Diag.Message.Fix = Error.NoLintReplacements;
     TUD.Diagnostics.insert(TUD.Diagnostics.end(), Diag);
   }
 
   yaml::Output YAML(OS);
   YAML << TUD;
 }
 
 NamesAndOptions

clang-tools-extra/clang-tidy/ClangTidyDiagnosticConsumer.h

 ///
 /// FIXME: Make Diagnostics flexible enough to support this directly.
 struct ClangTidyError : tooling::Diagnostic {
   ClangTidyError(StringRef CheckName, Level DiagLevel, StringRef BuildDirectory,
                  bool IsWarningAsError);
 
   bool IsWarningAsError;
   std::vector<std::string> EnabledDiagnosticAliases;
+  llvm::StringMap<tooling::Replacements> NoLintReplacements;
 };
 
 /// Contains displayed and ignored diagnostic counters for a ClangTidy run.
 struct ClangTidyStats {
   unsigned ErrorsDisplayed = 0;
   unsigned ErrorsIgnoredCheckFilter = 0;
   unsigned ErrorsIgnoredNOLINT = 0;
   unsigned ErrorsIgnoredNonUserCode = 0;
private:
   bool AllowEnablingAnalyzerAlphaCheckers;
 
   bool SelfContainedDiags;
 
   NoLintDirectiveHandler NoLintHandler;
   llvm::StringSet<> *OptionsCollector = nullptr;
 };
 
-/// Gets the Fix attached to \p Diagnostic.
+/// Controls how clang-tidy applies fixes.
+enum FixType {
+  /// Only apply fix-its.
+  FT_FixIt,
+  /// Only add NOLINT lines.
+  FT_NoLint,
+  /// Add NOLINT if fix-it is not available.
+  FT_FixItOrNoLint
+};
+
+/// Gets the Fix attached to \p ClangTidyError.
 /// If there isn't a Fix attached to the diagnostic and \p AnyFix is true, Check
 /// to see if exactly one note has a Fix and return it. Otherwise return
 /// nullptr.
-const llvm::StringMap<tooling::Replacements> *
-getFixIt(const tooling::Diagnostic &Diagnostic, bool AnyFix);
+std::pair<const llvm::StringMap<tooling::Replacements> *, FixType>
+getFixIt(const ClangTidyError &Error, FixType Type, bool AnyFix);
 
 /// A diagnostic consumer that turns each \c Diagnostic into a
 /// \c SourceManager-independent \c ClangTidyError.
 // FIXME: If we move away from unit-tests, this can be moved to a private
 // implementation file.
 class ClangTidyDiagnosticConsumer : public DiagnosticConsumer {
 public:
   /// \param EnableNolintBlocks Enables diagnostic-disabling inside blocks of
   /// code, delimited by NOLINTBEGIN and NOLINTEND.
   ClangTidyDiagnosticConsumer(ClangTidyContext &Ctx,
                               DiagnosticsEngine *ExternalDiagEngine = nullptr,
                               bool RemoveIncompatibleErrors = true,
                               bool GetFixesFromNotes = false,
+                              FixType Type = FT_FixIt,
+                              StringRef NoLintPrefix = "",
                               bool EnableNolintBlocks = true);
 
   // FIXME: The concept of converting between FixItHints and Replacements is
   // more generic and should be pulled out into a more useful Diagnostics
   // library.
   void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
                         const Diagnostic &Info) override;
 
private:
   bool passesLineFilter(StringRef FileName, unsigned LineNumber) const;
 
   void forwardDiagnostic(const Diagnostic &Info);
 
   ClangTidyContext &Context;
   DiagnosticsEngine *ExternalDiagEngine;
   bool RemoveIncompatibleErrors;
   bool GetFixesFromNotes;
+  FixType Type;
+  StringRef NoLintPrefix;
   bool EnableNolintBlocks;
   std::vector<ClangTidyError> Errors;
   std::unique_ptr<llvm::Regex> HeaderFilter;
   bool LastErrorRelatesToUserCode;
   bool LastErrorPassesLineFilter;
   bool LastErrorWasIgnored;
 };
 
 } // end namespace tidy
 } // end namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYDIAGNOSTICCONSUMER_H

clang-tools-extra/clang-tidy/ClangTidyDiagnosticConsumer.cpp

 
 #include "ClangTidyDiagnosticConsumer.h"
 #include "ClangTidyOptions.h"
 #include "GlobList.h"
 #include "NoLintDirectiveHandler.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTDiagnostic.h"
 #include "clang/AST/Attr.h"
+#include "clang/Basic/CharInfo.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Frontend/DiagnosticRenderer.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Tooling/Core/Diagnostic.h"
 #include "clang/Tooling/Core/Replacement.h"
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/Regex.h"
 #include <optional>
 #include <tuple>
 #include <utility>
 #include <vector>
 using namespace clang;
 using namespace tidy;
 
 namespace {
+/// Returns the pointer that points to the beginning of line that contains
+/// the given offset, or null if the offset if invalid.
+const char *findBeginningOfLine(StringRef Buffer, unsigned Offset) {
+  const char *BufStart = Buffer.data();
+  if (Offset >= Buffer.size())
+    return nullptr;
+
+  const char *LexStart = BufStart + Offset;
+  for (; LexStart != BufStart; --LexStart) {
+    if (isVerticalWhitespace(LexStart[0]) &&
+        !Lexer::isNewLineEscaped(BufStart, LexStart)) {
+      // LexStart should point at first character of logical line.
+      ++LexStart;
+      break;
+    }
+  }
+  return LexStart;
+}
+
+void computeNoLintReplacements(FullSourceLoc Loc, ClangTidyError &Error,
+                               StringRef NoLintPrefix) {
+  if (!Loc.isValid())
+    return;
+
+  StringRef Buf = Loc.getBufferData();
+  const char *Begin = findBeginningOfLine(Buf, Error.Message.FileOffset);
+  tooling::Replacement Repl(
+      Error.Message.FilePath, Begin - Buf.data(), 0,
+      (Lexer::getIndentationForLine(Loc, Loc.getManager()) + "/* " +
+       NoLintPrefix + "NOLINTNEXTLINE(" + Error.DiagnosticName + ") */\n")
+          .str());
+  assert(!Error.NoLintReplacements[Error.Message.FilePath].add(Repl));
+}
+
 class ClangTidyDiagnosticRenderer : public DiagnosticRenderer {
 public:
   ClangTidyDiagnosticRenderer(const LangOptions &LangOpts,
                               DiagnosticOptions *DiagOpts,
-                              ClangTidyError &Error)
-      : DiagnosticRenderer(LangOpts, DiagOpts), Error(Error) {}
+                              ClangTidyError &Error, StringRef NoLintPrefix)
+      : DiagnosticRenderer(LangOpts, DiagOpts), Error(Error),
+        NoLintPrefix(NoLintPrefix) {}
 
 protected:
   void emitDiagnosticMessage(FullSourceLoc Loc, PresumedLoc PLoc,
                              DiagnosticsEngine::Level Level, StringRef Message,
                              ArrayRef<CharSourceRange> Ranges,
                              DiagOrStoredDiag Info) override {
     // Remove check name from the message.
     // FIXME: Remove this once there's a better way to pass check names than
if (Level == DiagnosticsEngine::Note) {
                                                ToCharRange(SourceRange));
       return;
     }
     assert(Error.Message.Message.empty() && "Overwriting a diagnostic message");
     Error.Message = TidyMessage;
     for (const CharSourceRange &SourceRange : ValidRanges)
       Error.Message.Ranges.emplace_back(Loc.getManager(),
                                         ToCharRange(SourceRange));
+    computeNoLintReplacements(Loc, Error, NoLintPrefix);
   }
 
   void emitDiagnosticLoc(FullSourceLoc Loc, PresumedLoc PLoc,
                          DiagnosticsEngine::Level Level,
                          ArrayRef<CharSourceRange> Ranges) override {}
 
   void emitCodeContext(FullSourceLoc Loc, DiagnosticsEngine::Level Level,
                        SmallVectorImpl<CharSourceRange> &Ranges,
protected:
 
   void endDiagnostic(DiagOrStoredDiag D,
                      DiagnosticsEngine::Level Level) override {
     assert(!Error.Message.Message.empty() && "Message has not been set");
   }
 
 private:
   ClangTidyError &Error;
+  StringRef NoLintPrefix;
 };
 } // end anonymous namespace
 
 ClangTidyError::ClangTidyError(StringRef CheckName,
                                ClangTidyError::Level DiagLevel,
                                StringRef BuildDirectory, bool IsWarningAsError)
     : tooling::Diagnostic(CheckName, DiagLevel, BuildDirectory),
       IsWarningAsError(IsWarningAsError) {}
llvm::DenseMap<unsigned, std::string>::const_iterator I =
       CheckNamesByDiagnosticID.find(DiagnosticID);
   if (I != CheckNamesByDiagnosticID.end())
     return I->second;
   return "";
 }
 
 ClangTidyDiagnosticConsumer::ClangTidyDiagnosticConsumer(
     ClangTidyContext &Ctx, DiagnosticsEngine *ExternalDiagEngine,
-    bool RemoveIncompatibleErrors, bool GetFixesFromNotes,
-    bool EnableNolintBlocks)
+    bool RemoveIncompatibleErrors, bool GetFixesFromNotes, FixType Type,
+    StringRef NoLintPrefix, bool EnableNolintBlocks)
     : Context(Ctx), ExternalDiagEngine(ExternalDiagEngine),
       RemoveIncompatibleErrors(RemoveIncompatibleErrors),
-      GetFixesFromNotes(GetFixesFromNotes),
-      EnableNolintBlocks(EnableNolintBlocks), LastErrorRelatesToUserCode(false),
-      LastErrorPassesLineFilter(false), LastErrorWasIgnored(false) {}
+      GetFixesFromNotes(GetFixesFromNotes), Type(Type),
+      NoLintPrefix(NoLintPrefix), EnableNolintBlocks(EnableNolintBlocks),
+      LastErrorRelatesToUserCode(false), LastErrorPassesLineFilter(false),
+      LastErrorWasIgnored(false) {}
 
 void ClangTidyDiagnosticConsumer::finalizeLastError() {
   if (!Errors.empty()) {
     ClangTidyError &Error = Errors.back();
     if (Error.DiagnosticName == "clang-tidy-config") {
       // Never ignore these.
     } else if (!Context.isCheckEnabled(Error.DiagnosticName) &&
                Error.DiagLevel != ClangTidyError::Error) {
if (!Errors.empty()) {
     }
   }
   LastErrorRelatesToUserCode = false;
   LastErrorPassesLineFilter = false;
 }
 
 namespace clang::tidy {
 
-const llvm::StringMap<tooling::Replacements> *
-getFixIt(const tooling::Diagnostic &Diagnostic, bool GetFixFromNotes) {
-  if (!Diagnostic.Message.Fix.empty())
-    return &Diagnostic.Message.Fix;
+std::pair<const llvm::StringMap<tooling::Replacements> *, FixType>
+getFixIt(const ClangTidyError &Error, FixType Type, bool GetFixFromNotes) {
+  const llvm::StringMap<tooling::Replacements> *Result = nullptr;
+  FixType AppliedType = FT_FixIt;
+  if (Type == FT_FixIt || Type == FT_FixItOrNoLint) {
+    auto GetFix =
+        [&Error,
+         GetFixFromNotes]() -> const llvm::StringMap<tooling::Replacements> * {
+      if (!Error.Message.Fix.empty())
+        return &Error.Message.Fix;
       if (!GetFixFromNotes)
         return nullptr;
       const llvm::StringMap<tooling::Replacements> *Result = nullptr;
-  for (const auto &Note : Diagnostic.Notes) {
+      for (const auto &Note : Error.Notes) {
         if (!Note.Fix.empty()) {
           if (Result)
             // We have 2 different fixes in notes, bail out.
             return nullptr;
           Result = &Note.Fix;
         }
       }
       return Result;
+    };
+    Result = GetFix();
+    AppliedType = FT_FixIt;
+  }
+  if ((Type == FT_NoLint || Type == FT_FixItOrNoLint) && !Result) {
+    Result = &Error.NoLintReplacements;
+    AppliedType = FT_NoLint;
+  }
+  return std::make_pair(Result, AppliedType);
 }
 
 } // namespace clang::tidy
 
 void ClangTidyDiagnosticConsumer::HandleDiagnostic(
     DiagnosticsEngine::Level DiagLevel, const Diagnostic &Info) {
   if (LastErrorWasIgnored && DiagLevel == DiagnosticsEngine::Note)
     return;
void ClangTidyDiagnosticConsumer::HandleDiagnostic(
 
   if (ExternalDiagEngine) {
     // If there is an external diagnostics engine, like in the
     // ClangTidyPluginAction case, forward the diagnostics to it.
     forwardDiagnostic(Info);
   } else {
     ClangTidyDiagnosticRenderer Converter(
         Context.getLangOpts(), &Context.DiagEngine->getDiagnosticOptions(),
-        Errors.back());
+        Errors.back(), NoLintPrefix);
     SmallString<100> Message;
     Info.FormatDiagnostic(Message);
     FullSourceLoc Loc;
     if (Info.getLocation().isValid() && Info.hasSourceManager())
       Loc = FullSourceLoc(Info.getLocation(), Info.getSourceManager());
     Converter.emitDiagnostic(Loc, DiagLevel, Message, Info.getRanges(),
                              Info.getFixItHints());
   }
void ClangTidyDiagnosticConsumer::removeIncompatibleErrors() {
   removeDuplicatedDiagnosticsOfAliasCheckers();
 
   // Compute error sizes.
   std::vector<int> Sizes;
   std::vector<
       std::pair<ClangTidyError *, llvm::StringMap<tooling::Replacements> *>>
       ErrorFixes;
   for (auto &Error : Errors) {
-    if (const auto *Fix = getFixIt(Error, GetFixesFromNotes))
+    const auto Fix = getFixIt(Error, Type, GetFixesFromNotes);
+    if (Fix.first)
       ErrorFixes.emplace_back(
-          &Error, const_cast<llvm::StringMap<tooling::Replacements> *>(Fix));
+          &Error,
+          const_cast<llvm::StringMap<tooling::Replacements> *>(Fix.first));
   }
   for (const auto &ErrorAndFix : ErrorFixes) {
     int Size = 0;
     for (const auto &FileAndReplaces : *ErrorAndFix.second) {
       for (const auto &Replace : FileAndReplaces.second)
         Size += Replace.getLength();
     }
     Sizes.push_back(Size);

clang-tools-extra/clang-tidy/tool/ClangTidyMain.cpp

 If a warning has no fix, but a single fix can 
 be found through an associated diagnostic note, 
 apply the fix. 
 Specifying this flag will implicitly enable the 
 '--fix' flag.
 )"),
                               cl::init(false), cl::cat(ClangTidyCategory));
 
+static cl::opt<std::string> FixMode("fix-mode", cl::desc(R"(
+How to fix warnings:
+  - 'fixit' (default) applies fix-it if available
+  - 'nolint' adds a NOLINT comment to suppress the
+    warning, prefixed with the value of the
+    --nolint-prefix argument
+  - 'fixit-or-nolint' applies fix-it if available,
+    otherwise adds a NOLINT comment like the 'nolint'
+    option
+)"),
+                                    cl::init("fixit"),
+                                    cl::cat(ClangTidyCategory));
+
+static cl::opt<std::string> NoLintPrefix("nolint-prefix", cl::desc(R"(
+Prefix to be added to NOLINT comments.
+)"),
+                                         cl::init(""),
+                                         cl::cat(ClangTidyCategory));
+
 static cl::opt<std::string> FormatStyle("format-style", cl::desc(R"(
 Style for formatting code around applied fixes:
   - 'none' (default) turns off formatting
   - 'file' (literally 'file', not a placeholder)
     uses .clang-format file in the closest parent
     directory
   - '{ <json> }' specifies options inline, e.g.
     -format-style='{BasedOnStyle: llvm, IndentWidth: 8}'
int clangTidyMain(int argc, const char **argv) {
   llvm::Expected<CommonOptionsParser> OptionsParser =
       CommonOptionsParser::create(argc, argv, ClangTidyCategory,
                                   cl::ZeroOrMore);
   if (!OptionsParser) {
     llvm::WithColor::error() << llvm::toString(OptionsParser.takeError());
     return 1;
   }
 
+  FixType Type = FT_FixIt;
+  if (FixMode.getValue() == "fixit")
+    Type = FT_FixIt;
+  else if (FixMode.getValue() == "nolint")
+    Type = FT_NoLint;
+  else if (FixMode.getValue() == "fixit-or-nolint")
+    Type = FT_FixItOrNoLint;
+  else {
+    llvm::WithColor::error()
+        << "invalid value for --fix-type: '" << FixMode.getValue() << "'\n";
+    return 1;
+  }
+
   llvm::IntrusiveRefCntPtr<vfs::OverlayFileSystem> BaseFS(
       new vfs::OverlayFileSystem(vfs::getRealFileSystem()));
 
   if (!VfsOverlay.empty()) {
     IntrusiveRefCntPtr<vfs::FileSystem> VfsFromFile =
         getVfsFromFile(VfsOverlay, BaseFS);
     if (!VfsFromFile)
       return 1;
int clangTidyMain(int argc, const char **argv) {
   }
 
   llvm::InitializeAllTargetInfos();
   llvm::InitializeAllTargetMCs();
   llvm::InitializeAllAsmParsers();
 
   ClangTidyContext Context(std::move(OwningOptionsProvider),
                            AllowEnablingAnalyzerAlphaCheckers);
-  std::vector<ClangTidyError> Errors =
-      runClangTidy(Context, OptionsParser->getCompilations(), PathList, BaseFS,
-                   FixNotes, EnableCheckProfile, ProfilePrefix);
+  std::vector<ClangTidyError> Errors = runClangTidy(
+      Context, OptionsParser->getCompilations(), PathList, BaseFS, FixNotes,
+      Type, NoLintPrefix.getValue(), EnableCheckProfile, ProfilePrefix);
   bool FoundErrors = llvm::any_of(Errors, [](const ClangTidyError &E) {
     return E.DiagLevel == ClangTidyError::Error;
   });
 
   // --fix-errors and --fix-notes imply --fix.
   FixBehaviour Behaviour = FixNotes             ? FB_FixNotes
                            : (Fix || FixErrors) ? FB_Fix
                                                 : FB_NoFix;
 
   const bool DisableFixes = FoundErrors && !FixErrors;
 
   unsigned WErrorCount = 0;
 
-  handleErrors(Errors, Context, DisableFixes ? FB_NoFix : Behaviour,
+  handleErrors(Errors, Context, DisableFixes ? FB_NoFix : Behaviour, Type,
                WErrorCount, BaseFS);
 
   if (!ExportFixes.empty() && !Errors.empty()) {
     std::error_code EC;
     llvm::raw_fd_ostream OS(ExportFixes, EC, llvm::sys::fs::OF_None);
     if (EC) {
       llvm::errs() << "Error opening output file: " << EC.message() << '\n';
       return 1;
     }
-    exportReplacements(FilePath.str(), Errors, OS);
+    exportReplacements(FilePath.str(), Errors, OS, Type);
   }
 
   if (!Quiet) {
     printStats(Context.getStats());
     if (DisableFixes && Behaviour != FB_NoFix)
       llvm::errs()
           << "Found compiler errors, but -fix-errors was not specified.\n"
              "Fixes have NOT been applied.\n\n";

clang/include/clang/Basic/DiagnosticFrontendKinds.td

def err_verify_invalid_no_diags : Error<
     "%select{expected|'expected-no-diagnostics'}0 directive cannot follow "
     "%select{'expected-no-diagnostics' directive|other expected directives}0">;
 def err_verify_no_directives : Error<
     "no expected directives found: consider use of 'expected-no-diagnostics'">;
 def err_verify_nonconst_addrspace : Error<
   "qualifier 'const' is needed for variables in address space '%0'">;
 
 def note_fixit_applied : Note<"FIX-IT applied suggested code changes">;
+def note_fixit_added_nolint : Note<"FIX-IT added NOLINT to suppress warning">;
 def note_fixit_in_macro : Note<
     "FIX-IT unable to apply suggested code changes in a macro">;
 def note_fixit_failed : Note<
     "FIX-IT unable to apply suggested code changes">;
 def note_fixit_unfixed_error : Note<"FIX-IT detected an error it cannot fix">;
 def warn_fixit_no_changes : Note<
     "FIX-IT detected errors it could not fix; no output will be generated">;