[clang-tidy] Implement clang-tidy check aliases

[leanil]

Summary

Clang warnings can be mapped to virtual check names as aliases. The mappings can be set in the appropriate ClangTidyModules. If the virtual check is enabled, then

• the corresponding warning options get passed to clang, and
• the warning names are replaced with the check alias in the produced messages.

This is an implementation of the proposal here.

[aaron.ballman]

Thank you for working on this -- it's very nice functionality!

clang-tidy/cert/CERTTidyModule.cpp

78

You should declare this as override.

79–81

Can you use try_emplace() instead of insert() -- this removes the need for the braced initializers to create the pair.

82

This check also needs a test case.

[alexfh]

András, that's definitely an interesting idea. However, it might be interesting to explore a more principled approach:

1. Make clang-diagnostic-* checks first-class citizens and take full control of all diagnostics, i.e. disable all Clang diagnostics by default, and enable the ones that correspond to the enabled clang-diagnostic checks.
2. Make aliases first-class citizens (there was a proposal as well, but we didn't arrive to a consensus at that time). That would include the ability to configure an alias name for any check including clang-diagnostic- and clang-analyzer- checks.
3. Use aliases to map clang-diagnostic- checks to check names under cert-, hicpp-, etc.

I didn't carefully consider all possible implications and there may be issues with any or all of the three parts of this, but I think it's worth exploring.

[lebedev.ri]

On a somewhat related note, since this is already talking about aliases

I feel like the current handling of the clang-tidy check aliases needs adjusting.
If one enables all the checks (Checks: '*'), and then disables some of them
on check-by-check basis, if the disabled check has aliases
(cppcoreguidelines-pro-type-vararg vs hicpp-vararg, hicpp-no-array-decay
vs cppcoreguidelines-pro-bounds-array-to-pointer-decay and so on)
each of the aliases must be explicitly be disabled too.

This is rather inconvenient.

If that is intentional, perhaps there could be a config option to either disable
creation/registration of the check aliases altogether, or an option to threat
aliases as a hard link, so anything happening to any of the aliases/base check
would happen to all of them.

(Also, if the check has parameters, and one specifies different parameters for the base check, and the aliases, what happens?)

[xazax.hun]

@leanil : Could you add a test case where the warnings are explicitly disabled in the compilation command and also one where only the aliased warning is explicitly disabled?

In D38171#878814, @lebedev.ri wrote:

I feel like the current handling of the clang-tidy check aliases needs adjusting.
If one enables all the checks (Checks: '*'), and then disables some of them
on check-by-check basis, if the disabled check has aliases
(cppcoreguidelines-pro-type-vararg vs hicpp-vararg, hicpp-no-array-decay
vs cppcoreguidelines-pro-bounds-array-to-pointer-decay and so on)
each of the aliases must be explicitly be disabled too.

That is somewhat intentional I think. Lets imagined you are interested in cppcoreguidelines but not interested in high integrity cpp. It would be great to be able to use Checks: 'cppcoreguidelines*,-hicpp*' without having to worry about the aliases.

In D38171#878814, @lebedev.ri wrote:

If that is intentional, perhaps there could be a config option to either disable
creation/registration of the check aliases altogether, or an option to threat
aliases as a hard link, so anything happening to any of the aliases/base check
would happen to all of them.

I think the source of the problems is that conceptually there are two distinct reasons to disable a check. One reason when the user is not interested in the results regardless what is the category or name of the check. In this case, all aliases should be disabled. The second is when a category of checks (e.g.: a guideline) is not applicable to the code. In this case aliases should not be disabled. So I think a global option would not solve this issue. A better solution might be a per glob notation. So - could mean do not disable aliases and -- could mean disable aliases as well but that is just an example.

All in all, I think this is not related strictly to this issue and I think we should discuss this separately on the mailing list.

In D38171#878814, @lebedev.ri wrote:

(Also, if the check has parameters, and one specifies different parameters for the base check, and the aliases, what happens?)

I think this is a very good point, this needs to be documented somewhere.

[xazax.hun]

In D38171#878808, @alexfh wrote:

András, that's definitely an interesting idea. However, it might be interesting to explore a more principled approach:

1. Make clang-diagnostic-* checks first-class citizens and take full control of all diagnostics, i.e. disable all Clang diagnostics by default, and enable the ones that correspond to the enabled clang-diagnostic checks.

I agree that this is a good idea. I think it could be done in this patch. But to be sure, could you elaborate on what do you mean by first-class citizen?

2. Make aliases first-class citizens (there was a proposal as well, but we didn't arrive to a consensus at that time). That would include the ability to configure an alias name for any check including clang-diagnostic- and clang-analyzer- checks.

Do you have a link to the proposal? What do you mean by the ability to configure? As in having a config file or registering aliases in modules like now? If you mean the former, I think that is better addressed in a follow-up patch.

3. Use aliases to map clang-diagnostic- checks to check names under cert-, hicpp-, etc.

I didn't carefully consider all possible implications and there may be issues with any or all of the three parts of this, but I think it's worth exploring.

[lebedev.ri]

In D38171#880016, @xazax.hun wrote:

In D38171#878814, @lebedev.ri wrote:

I feel like the current handling of the clang-tidy check aliases needs adjusting.
If one enables all the checks (Checks: '*'), and then disables some of them
on check-by-check basis, if the disabled check has aliases
(cppcoreguidelines-pro-type-vararg vs hicpp-vararg, hicpp-no-array-decay
vs cppcoreguidelines-pro-bounds-array-to-pointer-decay and so on)
each of the aliases must be explicitly be disabled too.

That is somewhat intentional I think. Lets imagined you are interested in cppcoreguidelines but not interested in high integrity cpp. It would be great to be able to use Checks: 'cppcoreguidelines*,-hicpp*' without having to worry about the aliases.

In D38171#878814, @lebedev.ri wrote:

If that is intentional, perhaps there could be a config option to either disable
creation/registration of the check aliases altogether, or an option to threat
aliases as a hard link, so anything happening to any of the aliases/base check
would happen to all of them.

I think the source of the problems is that conceptually there are two distinct reasons to disable a check. One reason when the user is not interested in the results regardless what is the category or name of the check. In this case, all aliases should be disabled. The second is when a category of checks (e.g.: a guideline) is not applicable to the code. In this case aliases should not be disabled. So I think a global option would not solve this issue. A better solution might be a per glob notation. So - could mean do not disable aliases and -- could mean disable aliases as well but that is just an example.

All in all, I think this is not related strictly to this issue and I think we should discuss this separately on the mailing list.

In D38171#878814, @lebedev.ri wrote:

(Also, if the check has parameters, and one specifies different parameters for the base check, and the aliases, what happens?)

I think this is a very good point, this needs to be documented somewhere.

A mail [0] posted by @JonasToth is about the similar problem, i think we can continue there.

I *think* he has a point, a some better way to setup aliases, without actually
creating aliased checks is the solution IMO. This way, there won't be any
need to disable all the aliases when completely disabling the checks, and
there won't be multiple config options for the each alias. The legacy support
is the question though.

[0] (https://lists.llvm.org/pipermail/cfe-dev/2017-September/055589.html)

[alexfh]

In D38171#878814, @lebedev.ri wrote:

On a somewhat related note, since this is already talking about aliases

I feel like the current handling of the clang-tidy check aliases needs adjusting.
If one enables all the checks (Checks: '*'), and then disables some of them
on check-by-check basis,

Clang-tidy allows doing so, but I doubt this is a use case we want to encourage. At least, not for a day-to-day use. Most checks require a certain amount of work on the target code and sometimes fine tuning of the check options to be useful for any real codebase. Apart from that, there are checks that give duplicate warnings (some are aliases and some just cover intersecting set of issues), and there are checks that can give conflicting advice. These facts don't combine well with the "enable almost all checks" use case and limit its area of applicability to stress-testing clang-tidy and maybe to initial evaluation of clang-tidy checks on a certain codebase (though going from the other direction and determining the set of style rules for the codebase and then finding which of those are implemented in clang-tidy is a more fruitful approach).

if the disabled check has aliases
(cppcoreguidelines-pro-type-vararg vs hicpp-vararg, hicpp-no-array-decay
vs cppcoreguidelines-pro-bounds-array-to-pointer-decay and so on)
each of the aliases must be explicitly be disabled too.

It seems to be the least confusing of possible options. Gabor made a good point why this is useful as it is.

This is rather inconvenient.

If that is intentional, perhaps there could be a config option to either disable
creation/registration of the check aliases altogether, or an option to threat
aliases as a hard link, so anything happening to any of the aliases/base check
would happen to all of them.

(Also, if the check has parameters, and one specifies different parameters for the base check, and the aliases, what happens?)

[xazax.hun]

In D38171#880022, @lebedev.ri wrote:

A mail [0] posted by @JonasToth is about the similar problem, i think we can continue there.

Great! Could you summarize your points there as well? Thanks in advance.

[lebedev.ri]

In D38171#880025, @xazax.hun wrote:

In D38171#880022, @lebedev.ri wrote:

A mail [0] posted by @JonasToth is about the similar problem, i think we can continue there.

Great! Could you summarize your points there as well? Thanks in advance.

Done.

In D38171#880024, @alexfh wrote:

In D38171#878814, @lebedev.ri wrote:

On a somewhat related note, since this is already talking about aliases

I feel like the current handling of the clang-tidy check aliases needs adjusting.
If one enables all the checks (Checks: '*'), and then disables some of them
on check-by-check basis,

Clang-tidy allows doing so, but I doubt this is a use case we want to encourage.
At least, not for a day-to-day use.

It's much like clang's -Weverything, which is rather convenient, and is
inconveniently 'missing' in gcc, because the devs believe that there would
be complains that it results in new warnings each release,
which is kinda the point of that flag...

Most checks require a certain amount of work on the target code and sometimes
fine tuning of the check options to be useful for any real codebase. Apart from that,
there are checks that give duplicate warnings (some are aliases and some just cover
intersecting set of issues), and there are checks that can give conflicting advice.
These facts don't combine well with the "enable almost all checks" use case and limit
its area of applicability to stress-testing clang-tidy and maybe to initial evaluation of
clang-tidy checks on a certain codebase (though going from the other direction and
determining the set of style rules for the codebase and then finding which of those
are implemented in clang-tidy is a more fruitful approach).

Except the disagreeing checks, same could be said about -Weverything, clang-analyzer,
etc :) Yes, of course it does not just work, and of course needs some further tuning,
and of course the codebase that is being checked needs to be fixed not to warn.

I.e. the use-case is to always have all the warnings enabled, and each time a new check
is triggered, analyze whether it should be kept enabled, or disable it.

[leanil]

Add more tests and minor fixes.

[leanil]

In D38171#880021, @xazax.hun wrote:

In D38171#878808, @alexfh wrote:

András, that's definitely an interesting idea. However, it might be interesting to explore a more principled approach:

1. Make clang-diagnostic-* checks first-class citizens and take full control of all diagnostics, i.e. disable all Clang diagnostics by default, and enable the ones that correspond to the enabled clang-diagnostic checks.

I agree that this is a good idea. I think it could be done in this patch. But to be sure, could you elaborate on what do you mean by first-class citizen?

2. Make aliases first-class citizens (there was a proposal as well, but we didn't arrive to a consensus at that time). That would include the ability to configure an alias name for any check including clang-diagnostic- and clang-analyzer- checks.

Do you have a link to the proposal? What do you mean by the ability to configure? As in having a config file or registering aliases in modules like now? If you mean the former, I think that is better addressed in a follow-up patch.

I also think this sounds good, though I'm not quite sure it can be done in this patch. Anyway, we should definitely specify what we expect from first-class citizen checks. Please correct & extend the list:

• can be enabled or disabled through a unique name
• can have config options
• can have aliases
• inherits ClangTidyCheck

I see the last one as a requirement for handling everything uniformly (without workarounds like this patch), but also as a main point where an alias differs from a "real" check.

[xazax.hun]

Let's also summarize what do we have now and what do we want.

I also think this sounds good, though I'm not quite sure it can be done in this patch. Anyway, we should definitely specify what we expect from first-class citizen checks. Please correct & extend the list:

• can be enabled or disabled through a unique name

This is addressed by the current pathc.

• can have config options

Do you know warnings that have config options? Does this make sense for this featre?

• can have aliases

Does that make sense to be able to add aliases to warning aliases? I

• inherits ClangTidyCheck

I think this is just technical and this does not really affect the users.

In D38171#878808, @alexfh wrote:

1. Make clang-diagnostic-* checks first-class citizens and take full control of all diagnostics, i.e. disable all Clang diagnostics by default, and enable the ones that correspond to the enabled clang-diagnostic checks.

I think this might be a good idea in general. @leanil could you address this point in this patch?

2. Make aliases first-class citizens (there was a proposal as well, but we didn't arrive to a consensus at that time). That would include the ability to configure an alias name for any check including clang-diagnostic- and clang-analyzer- checks.

I am not sure that this makes sense, see my points above.

3. Use aliases to map clang-diagnostic- checks to check names under cert-, hicpp-, etc.

I agree.

[xazax.hun]

One problem to think about when we add all clang-diagnostic as "first or second" class citizen, checkes=* might now enable all the warnings which make no sense and might be surprising to the users. What do you think?

[leanil]

Make clang-diagnostic-* checks first-class citizens and take full control of all diagnostics, i.e. disable all Clang diagnostics by default, and enable the ones that correspond to the enabled clang-diagnostic checks.

(As @alexfh suggested.)

Collecting all the diagnostics seems to be possible from multiple sources, I've decided to make DiagnosticIDs::getAllDiagnostics static.
I also had to replace explicit -W arguments with the new checks in some of the tests.

[leanil]

In D38171#901427, @xazax.hun wrote:

One problem to think about when we add all clang-diagnostic as "first or second" class citizen, checkes=* might now enable all the warnings which make no sense and might be surprising to the users. What do you think?

This is a good point. Should I insert ",-clang-diagnostic*" after any (positive) * ?

[xazax.hun]

In D38171#909346, @leanil wrote:

In D38171#901427, @xazax.hun wrote:

One problem to think about when we add all clang-diagnostic as "first or second" class citizen, checkes=* might now enable all the warnings which make no sense and might be surprising to the users. What do you think?

This is a good point. Should I insert ",-clang-diagnostic*" after any (positive) * ?

@alexfh do you have some thoughts on this?

[alexfh]

In D38171#925929, @xazax.hun wrote:

In D38171#909346, @leanil wrote:

In D38171#901427, @xazax.hun wrote:

One problem to think about when we add all clang-diagnostic as "first or second" class citizen, checkes=* might now enable all the warnings which make no sense and might be surprising to the users. What do you think?

This is a good point. Should I insert ",-clang-diagnostic*" after any (positive) * ?

@alexfh do you have some thoughts on this?

I don't think this particular point is a large concern. As I mentioned multiple times, enabling all checks is almost never useful due to many checks overlapping or producing conflicting advice. The only place I can think of, where -checks=* is useful is in combination with -list-checks, where the presence of clang-diagnostic- entries would be desired anyway.

[alexfh]

And, btw, sorry for the long delay. I've been on travelling / on vacation for the last few weeks.

[malcolm.parsons]

In D38171#927045, @alexfh wrote:

The only place I can think of, where -checks=* is useful is in combination with -list-checks, where the presence of clang-diagnostic- entries would be desired anyway.

Can we replace -list-checks with -list-enabled-checks and -list-all-checks? The current behaviour is confusing and recently caused Chandler to abandon a clang-tidy demo.

[xazax.hun]

In D38171#927046, @alexfh wrote:

And, btw, sorry for the long delay. I've been on travelling / on vacation for the last few weeks.

No problem. Will you have some time to think about the overall concept? Implementation and test wise it looks good to me.
I think this patch is a step in a good direction but of course, it is important for the community to agree on the approach.

test/clang-tidy/warning-check-aliases.cpp

10

There are some redundant empty lines.

[xazax.hun]

clang-tidy/ClangTidyDiagnosticConsumer.cpp

262

I am wondering if this is still a good candidate to be a small vector with this size. Maybe a regular vector with a reserve might be better?

[leanil]

Remove redundant empty lines.
Make list-clang-diagnostics test less strict.
Update getAllDiagnostics to use std::vector.

[leanil]

Does anyone have any more thoughts about this?

[xazax.hun]

@alexfh did you have any chance to think about this change?

[lebedev.ri]

While i don't have a leg to stand on here, i'd be *much* more comfortable if this would be a proper RFC mail in cfe-dev,
that would explore all the possible options (this, and the one from cfe-dev thread clang-tidy and CppCoreGuidelines),
and *explain* why one is chosen, and not the other one.

I still feel like that proposal is more sound.

[alexfh]

I apologize for completely ignoring this for a long time.

I'm totally fine taking full control of clang-diagnostic- "checks", i.e. automatically adding corresponding -W flags and removing all other -W flags (or prepending -Wno-everything).

However, could we split the aliases stuff to a separate patch? My concerns w.r.t. the current implementation:

1. it doesn't allow more than one alias to each diagnostic
2. it's not clear that clang diagnostic aliases need to be separate from aliases for native clang-tidy checks. It might be better to add a more high-level API to register aliases (e.g. registerCheckAlias(<alias name>, <check name>, <custom check options>)).

clang-tidy/ClangTidy.cpp

406

The "clang-diagnostic-" string is now repeated multiple times. Could you pull it out to a constant (or maybe llvm::StringRef getClangDiagnosticPrefix())?

clang-tidy/ClangTidyModule.h

96

Consider using llvm::StringMap.

[alexfh]

In D38171#1036893, @alexfh wrote:

I'm totally fine taking full control of clang-diagnostic- "checks", i.e. automatically adding corresponding -W flags and removing all other -W flags (or prepending -Wno-everything).

However, could we split the aliases stuff to a separate patch?

The other way round. It will be better to split the clang-diagnostic part to a separate patch, since this patch focuses on the aliases.

[alexfh]

test/clang-tidy/misc-suspicious-semicolon-fail.cpp

5

This reminds me that we should also filter out all -W(no-)error.* compiler arguments, if we're to take full control of clang diagnostics and make them behave closer to native checks.

test/clang-tidy/validate-check-names.cpp

2

Which clang diagnostic names fail this test?

clang-tidy/ClangTidy.cpp

 ClangTidyASTConsumerFactory::ClangTidyASTConsumerFactory(
     ClangTidyContext &Context)
     : Context(Context), CheckFactories(new ClangTidyCheckFactories) {
   for (ClangTidyModuleRegistry::iterator I = ClangTidyModuleRegistry::begin(),
                                          E = ClangTidyModuleRegistry::end();
        I != E; ++I) {
     std::unique_ptr<ClangTidyModule> Module(I->instantiate());
     Module->addCheckFactories(*CheckFactories);
+    Module->addWarningCheckAliases(Context.WarningCheckAliases);
   }
 }
 
 static void setStaticAnalyzerCheckerOpts(const ClangTidyOptions &Opts,
                                          AnalyzerOptionsRef AnalyzerOptions) {
   StringRef AnalyzerPrefix(AnalyzerCheckNamePrefix);
   for (const auto &Opt : Opts.CheckOptions) {
     StringRef OptName(Opt.first);

 
 std::vector<std::string> ClangTidyASTConsumerFactory::getCheckNames() {
   std::vector<std::string> CheckNames;
   for (const auto &CheckFactory : *CheckFactories) {
     if (Context.isCheckEnabled(CheckFactory.first))
       CheckNames.push_back(CheckFactory.first);
   }
 
+  for (const auto &Alias : Context.WarningCheckAliases)
+    if (Context.isCheckEnabled(Alias.second))
+      CheckNames.push_back(Alias.second);
+
+  for (const auto &Diag : Context.getEnabledClangDiagnostics())
+    CheckNames.push_back("clang-diagnostic-" + Diag);
+
   for (const auto &AnalyzerCheck : getCheckersControlList(Context))
     CheckNames.push_back(AnalyzerCheckNamePrefix + AnalyzerCheck.first);
 
   std::sort(CheckNames.begin(), CheckNames.end());
   return CheckNames;
 }
 
 ClangTidyOptions::OptionMap ClangTidyASTConsumerFactory::getCheckOptions() {
ArgumentsAdjuster PerFileExtraArgumentsInserter =
           if (I != AdjustedArgs.end() && !StringRef(*I).startswith("-"))
             ++I; // Skip compiler binary name, if it is there.
           AdjustedArgs.insert(I, Opts.ExtraArgsBefore->begin(),
                               Opts.ExtraArgsBefore->end());
         }
         if (Opts.ExtraArgs)
           AdjustedArgs.insert(AdjustedArgs.end(), Opts.ExtraArgs->begin(),
                               Opts.ExtraArgs->end());
+
+        AdjustedArgs.push_back("-Wno-everything");
+        for (const auto &Diag : Context.getEnabledClangDiagnostics())
+          AdjustedArgs.push_back("-W" + Diag);
+
+        for (const auto &Alias : Context.WarningCheckAliases)
+          if (Context.isCheckEnabled(Alias.second))
+            AdjustedArgs.push_back("-W" + Alias.first.str());
+
         return AdjustedArgs;
       };
 
   // Remove plugins arguments.
   ArgumentsAdjuster PluginArgumentsRemover =
       [](const CommandLineArguments &Args, StringRef Filename) {
         CommandLineArguments AdjustedArgs;
         for (size_t I = 0, E = Args.size(); I < E; ++I) {

clang-tidy/ClangTidyDiagnosticConsumer.h

 
 #include "ClangTidyOptions.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Tooling/Core/Diagnostic.h"
 #include "clang/Tooling/Refactoring.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Regex.h"
 #include "llvm/Support/Timer.h"
 
 namespace clang {
 
 class ASTContext;
 class CompilerInstance;
 namespace ast_matchers {
void setCurrentBuildDirectory(StringRef BuildDirectory) {
     CurrentBuildDirectory = BuildDirectory;
   }
 
   /// \brief Returns build directory of the current translation unit.
   const std::string &getCurrentBuildDirectory() {
     return CurrentBuildDirectory;
   }
 
+  std::vector<std::string> getEnabledClangDiagnostics();
+
+  llvm::DenseMap<llvm::StringRef, llvm::StringRef> WarningCheckAliases;
+
 private:
   // Calls setDiagnosticsEngine() and storeError().
   friend class ClangTidyDiagnosticConsumer;
   friend class ClangTidyPluginAction;
 
   /// \brief Sets the \c DiagnosticsEngine so that Diagnostics can be generated
   /// correctly.
   void setDiagnosticsEngine(DiagnosticsEngine *Engine);

clang-tidy/ClangTidyDiagnosticConsumer.cpp

 //===----------------------------------------------------------------------===//
 
 #include "ClangTidyDiagnosticConsumer.h"
 #include "ClangTidyOptions.h"
 #include "clang/AST/ASTDiagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Frontend/DiagnosticRenderer.h"
 #include "llvm/ADT/SmallString.h"
+#include <algorithm>
 #include <tuple>
 #include <vector>
 using namespace clang;
 using namespace tidy;
 
 namespace {
 class ClangTidyDiagnosticRenderer : public DiagnosticRenderer {
 public:

 StringRef ClangTidyContext::getCheckName(unsigned DiagnosticID) const {
   llvm::DenseMap<unsigned, std::string>::const_iterator I =
       CheckNamesByDiagnosticID.find(DiagnosticID);
   if (I != CheckNamesByDiagnosticID.end())
     return I->second;
   return "";
 }
 
+std::vector<std::string> ClangTidyContext::getEnabledClangDiagnostics() {
+  llvm::SmallVector<unsigned, 5000> Diags;
+  DiagnosticIDs::getAllDiagnostics(diag::Flavor::WarningOrError, Diags);
+  std::vector<std::string> EnabledClangDiagnostics;
+  for (unsigned DiagID : Diags) {
+    auto Flag = DiagnosticIDs::getWarningOptionForDiag(DiagID).str();
+    if (!Flag.empty() && isCheckEnabled("clang-diagnostic-" + Flag))
+      EnabledClangDiagnostics.push_back(Flag);
+  }
+  std::sort(EnabledClangDiagnostics.begin(), EnabledClangDiagnostics.end());
+  EnabledClangDiagnostics.erase(std::unique(EnabledClangDiagnostics.begin(),
+                                            EnabledClangDiagnostics.end()),
+                                EnabledClangDiagnostics.end());
+  return EnabledClangDiagnostics;
+}
+
 ClangTidyDiagnosticConsumer::ClangTidyDiagnosticConsumer(
     ClangTidyContext &Ctx, bool RemoveIncompatibleErrors)
     : Context(Ctx), RemoveIncompatibleErrors(RemoveIncompatibleErrors),
       LastErrorRelatesToUserCode(false), LastErrorPassesLineFilter(false),
       LastErrorWasIgnored(false) {
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
   Diags = llvm::make_unique<DiagnosticsEngine>(
       IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs), &*DiagOpts, this,
void ClangTidyDiagnosticConsumer::HandleDiagnostic(
   if (DiagLevel == DiagnosticsEngine::Note) {
     assert(!Errors.empty() &&
            "A diagnostic note can only be appended to a message.");
   } else {
     finalizeLastError();
     StringRef WarningOption =
         Context.DiagEngine->getDiagnosticIDs()->getWarningOptionForDiag(
             Info.getID());
-    std::string CheckName = !WarningOption.empty()
-                                ? ("clang-diagnostic-" + WarningOption).str()
-                                : Context.getCheckName(Info.getID()).str();
+    auto Alias = Context.WarningCheckAliases.find(WarningOption);
+    std::string CheckName;
+    if (Alias != Context.WarningCheckAliases.end() &&
+        Context.isCheckEnabled(Alias->second))
+      CheckName = Alias->second;
+    else
+      CheckName = !WarningOption.empty()
 
     if (CheckName.empty()) {
       // This is a compiler diagnostic without a warning option. Assign check
       // name based on its level.
       switch (DiagLevel) {
       case DiagnosticsEngine::Error:
       case DiagnosticsEngine::Fatal:
         CheckName = "clang-diagnostic-error";

clang-tidy/ClangTidyModule.h

 //===--- ClangTidyModule.h - clang-tidy -------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYMODULE_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYMODULE_H
 
 #include "ClangTidy.h"
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringRef.h"
 #include <functional>
 #include <map>
 #include <string>
 #include <utility>
 
 namespace clang {
 namespace tidy {

 class ClangTidyModule {
 public:
   virtual ~ClangTidyModule() {}
 
   /// \brief Implement this function in order to register all \c CheckFactories
   /// belonging to this module.
   virtual void addCheckFactories(ClangTidyCheckFactories &CheckFactories) = 0;
 
+  /// \brief Implement this function in order to register all warning-check
+  /// aliases belonging to this module.
+  virtual void addWarningCheckAliases(
+      llvm::DenseMap<llvm::StringRef, llvm::StringRef> &WarningCheckAliases) {}
+
   /// \brief Gets default options for checks defined in this module.
   virtual ClangTidyOptions getModuleOptions();
 };
 
 } // end namespace tidy
 } // end namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYMODULE_H

clang-tidy/cert/CERTTidyModule.cpp

void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<FloatLoopCounter>("cert-flp30-c");
     // FIO
     CheckFactories.registerCheck<misc::NonCopyableObjectsCheck>("cert-fio38-c");
     // ERR
     CheckFactories.registerCheck<StrToNumCheck>("cert-err34-c");
     // MSC
     CheckFactories.registerCheck<LimitedRandomnessCheck>("cert-msc30-c");
   }
+
+  void addWarningCheckAliases(llvm::DenseMap<llvm::StringRef, llvm::StringRef>
+                                  &WarningCheckAliases) override {
+    WarningCheckAliases.try_emplace("exceptions", "cert-err54-cpp");
+    WarningCheckAliases.try_emplace("invalid-offsetof", "cert-exp59-cpp");
+  }
 };
 
 } // namespace cert
 
 // Register the MiscTidyModule using this statically initialized variable.
 static ClangTidyModuleRegistry::Add<cert::CERTModule>
     X("cert-module",
       "Adds lint checks corresponding to CERT secure coding guidelines.");
 
 // This anchor is used to force the linker to link in the generated object file
 // and thus register the CERTModule.
 volatile int CERTModuleAnchorSource = 0;
 
 } // namespace tidy
 } // namespace clang

clang-tidy/tool/ClangTidyMain.cpp

configuration can be inspected using -dump-config:
     CheckOptions:
       - key:             some-check.SomeOption
         value:           'some value'
     ...
 
 )");
 
 const char DefaultChecks[] = // Enable these checks by default:
-    "clang-diagnostic-*,"    //   * compiler diagnostics
     "clang-analyzer-*";      //   * Static Analyzer checks
 
 static cl::opt<std::string> Checks("checks", cl::desc(R"(
 Comma-separated list of globs with optional '-'
 prefix. Globs are processed in order of
 appearance in the list. Globs without '-'
 prefix add checks with matching names to the
 set, globs with the '-' prefix remove checks

test/clang-tidy/cert-exp59-cpp.cpp

+// RUN: clang-tidy %s -checks='-*,clang-diagnostic-invalid-offsetof' -- 2>&1 | FileCheck -implicit-check-not='{{warning:|error:}}' %s
+// RUN: clang-tidy %s -checks='-*,cert-exp59-cpp' -- 2>&1 | FileCheck -implicit-check-not='{{warning:|error:}}' -check-prefix=CHECK2 %s
+// RUN: clang-tidy %s -- 2>&1 | FileCheck -allow-empty -implicit-check-not='{{warning:|error:}}' -check-prefix=CHECK3 %s
+
+#include <cstddef>
+
+struct D {
+    virtual void f() {}
+    int i;
+};
+
+void f() {
+    size_t Off = offsetof(D, i);
+    //CHECK: :[[@LINE-1]]:18: warning: offset of on non-POD type 'D' [clang-diagnostic-invalid-offsetof]
+    //CHECK2: :[[@LINE-2]]:18: warning: offset of on non-POD type 'D' [cert-exp59-cpp]
+}

test/clang-tidy/custom-diagnostics.cpp

-// RUN: clang-tidy -checks='-*,modernize-use-override,clang-diagnostic-shadow,clang-diagnostic-float-conversion' %s -- | count 0
+// RUN: clang-tidy -checks='-*,modernize-use-override' %s -- | count 0
+//
+// Clang-diagnostic checks completely override extra args:
+// RUN: clang-tidy -checks='-*,modernize-use-override,clang-diagnostic-shadow,clang-diagnostic-float-conversion' \
+// RUN:   -config='{ExtraArgs: ["-Wno-shadow","-Wno-float-conversion","-Wunused-variable"], ExtraArgsBefore: ["-Wno-shadow","-Wno-float-conversion","-Wunused-variable"]}' %s -- \
+// RUN:   | FileCheck -implicit-check-not='{{warning:|error:}}' %s
 //
 // Enable warnings using -config:
 // RUN: clang-tidy -checks='-*,modernize-use-override,clang-diagnostic-shadow,clang-diagnostic-float-conversion' \
 // RUN:   -config='{ExtraArgs: ["-Wshadow","-Wno-unused-variable"], ExtraArgsBefore: ["-Wno-shadow","-Wfloat-conversion","-Wunused-variable"]}' %s -- \
 // RUN:   | FileCheck -implicit-check-not='{{warning:|error:}}' %s
 //
 // ... -extra-arg:
 // RUN: clang-tidy -checks='-*,modernize-use-override,clang-diagnostic-shadow,clang-diagnostic-float-conversion' \

test/clang-tidy/diagnostic.cpp

 // RUN: clang-tidy -checks='-*,modernize-use-override' %s.nonexistent.cpp -- | FileCheck -check-prefix=CHECK1 -implicit-check-not='{{warning:|error:}}' %s
-// RUN: clang-tidy -checks='-*,clang-diagnostic-*,google-explicit-constructor' %s -- -fan-unknown-option | FileCheck -check-prefix=CHECK2 -implicit-check-not='{{warning:|error:}}' %s
-// RUN: clang-tidy -checks='-*,google-explicit-constructor,clang-diagnostic-literal-conversion' %s -- -fan-unknown-option | FileCheck -check-prefix=CHECK3 -implicit-check-not='{{warning:|error:}}' %s
-// RUN: clang-tidy -checks='-*,modernize-use-override,clang-diagnostic-macro-redefined' %s -- -DMACRO_FROM_COMMAND_LINE | FileCheck -check-prefix=CHECK4 -implicit-check-not='{{warning:|error:}}' %s
+// RUN: clang-tidy -checks='-*,google-explicit-constructor,clang-diagnostic-literal-conversion' %s -- -fan-unknown-option | FileCheck -check-prefix=CHECK2 -implicit-check-not='{{warning:|error:}}' %s
+// RUN: clang-tidy -checks='-*,modernize-use-override,clang-diagnostic-macro-redefined' %s -- -DMACRO_FROM_COMMAND_LINE | FileCheck -check-prefix=CHECK3 -implicit-check-not='{{warning:|error:}}' %s
 //
 // Now repeat the tests and ensure no other errors appear on stderr:
 // RUN: clang-tidy -checks='-*,modernize-use-override' %s.nonexistent.cpp -- 2>&1 | FileCheck -check-prefix=CHECK1 -implicit-check-not='{{warning:|error:}}' %s
-// RUN: clang-tidy -checks='-*,clang-diagnostic-*,google-explicit-constructor' %s -- -fan-unknown-option 2>&1 | FileCheck -check-prefix=CHECK2 -implicit-check-not='{{warning:|error:}}' %s
-// RUN: clang-tidy -checks='-*,google-explicit-constructor,clang-diagnostic-literal-conversion' %s -- -fan-unknown-option 2>&1 | FileCheck -check-prefix=CHECK3 -implicit-check-not='{{warning:|error:}}' %s
-// RUN: clang-tidy -checks='-*,modernize-use-override,clang-diagnostic-macro-redefined' %s -- -DMACRO_FROM_COMMAND_LINE 2>&1 | FileCheck -check-prefix=CHECK4 -implicit-check-not='{{warning:|error:}}' %s
+// RUN: clang-tidy -checks='-*,google-explicit-constructor,clang-diagnostic-literal-conversion' %s -- -fan-unknown-option 2>&1 | FileCheck -check-prefix=CHECK2 -implicit-check-not='{{warning:|error:}}' %s
+// RUN: clang-tidy -checks='-*,modernize-use-override,clang-diagnostic-macro-redefined' %s -- -DMACRO_FROM_COMMAND_LINE 2>&1 | FileCheck -check-prefix=CHECK3 -implicit-check-not='{{warning:|error:}}' %s
 //
 // Now create a directory with a compilation database file and ensure we don't
 // use it after failing to parse commands from the command line:
 //
 // RUN: mkdir -p %T/diagnostics/
 // RUN: echo '[{"directory": "%/T/diagnostics/","command": "clang++ -fan-option-from-compilation-database -c %/T/diagnostics/input.cpp", "file": "%/T/diagnostics/input.cpp"}]' > %T/diagnostics/compile_commands.json
 // RUN: cat %s > %T/diagnostics/input.cpp
 // RUN: clang-tidy -checks='-*,modernize-use-override' %T/diagnostics/nonexistent.cpp -- 2>&1 | FileCheck -check-prefix=CHECK1 -implicit-check-not='{{warning:|error:}}' %s
-// RUN: clang-tidy -checks='-*,clang-diagnostic-*,google-explicit-constructor' %T/diagnostics/input.cpp -- -fan-unknown-option 2>&1 | FileCheck -check-prefix=CHECK2 -implicit-check-not='{{warning:|error:}}' %s
-// RUN: clang-tidy -checks='-*,google-explicit-constructor,clang-diagnostic-literal-conversion' %T/diagnostics/input.cpp -- -fan-unknown-option 2>&1 | FileCheck -check-prefix=CHECK3 -implicit-check-not='{{warning:|error:}}' %s
-// RUN: clang-tidy -checks='-*,modernize-use-override,clang-diagnostic-macro-redefined' %T/diagnostics/input.cpp -- -DMACRO_FROM_COMMAND_LINE 2>&1 | FileCheck -check-prefix=CHECK4 -implicit-check-not='{{warning:|error:}}' %s
-// RUN: clang-tidy -checks='-*,clang-diagnostic-*,google-explicit-constructor' %T/diagnostics/input.cpp 2>&1 | FileCheck -check-prefix=CHECK5 -implicit-check-not='{{warning:|error:}}' %s
+// RUN: clang-tidy -checks='-*,google-explicit-constructor,clang-diagnostic-literal-conversion' %T/diagnostics/input.cpp -- -fan-unknown-option 2>&1 | FileCheck -check-prefix=CHECK2 -implicit-check-not='{{warning:|error:}}' %s
+// RUN: clang-tidy -checks='-*,modernize-use-override,clang-diagnostic-macro-redefined' %T/diagnostics/input.cpp -- -DMACRO_FROM_COMMAND_LINE 2>&1 | FileCheck -check-prefix=CHECK3 -implicit-check-not='{{warning:|error:}}' %s
+// RUN: clang-tidy -checks='-*,clang-diagnostic-literal-conversion,google-explicit-constructor' %T/diagnostics/input.cpp 2>&1 | FileCheck -check-prefix=CHECK4 -implicit-check-not='{{warning:|error:}}' %s
 
 // CHECK1: error: error reading '{{.*}}nonexistent.cpp' [clang-diagnostic-error]
 // CHECK2: error: unknown argument: '-fan-unknown-option' [clang-diagnostic-error]
-// CHECK3: error: unknown argument: '-fan-unknown-option' [clang-diagnostic-error]
-// CHECK5: error: unknown argument: '-fan-option-from-compilation-database' [clang-diagnostic-error]
+// CHECK4: error: unknown argument: '-fan-option-from-compilation-database' [clang-diagnostic-error]
 
-// CHECK2: :[[@LINE+3]]:9: warning: implicit conversion from 'double' to 'int' changes value from 1.5 to 1 [clang-diagnostic-literal-conversion]
-// CHECK3: :[[@LINE+2]]:9: warning: implicit conversion from 'double' to 'int' changes value
-// CHECK5: :[[@LINE+1]]:9: warning: implicit conversion from 'double' to 'int' changes value
+// CHECK2: :[[@LINE+2]]:9: warning: implicit conversion from 'double' to 'int' changes value from 1.5 to 1 [clang-diagnostic-literal-conversion]
+// CHECK4: :[[@LINE+1]]:9: warning: implicit conversion from 'double' to 'int' changes value
 int a = 1.5;
 
-// CHECK2: :[[@LINE+3]]:11: warning: single-argument constructors must be marked explicit
-// CHECK3: :[[@LINE+2]]:11: warning: single-argument constructors must be marked explicit
-// CHECK5: :[[@LINE+1]]:11: warning: single-argument constructors must be marked explicit
+// CHECK2: :[[@LINE+2]]:11: warning: single-argument constructors must be marked explicit
+// CHECK4: :[[@LINE+1]]:11: warning: single-argument constructors must be marked explicit
 class A { A(int) {} };
 
 #define MACRO_FROM_COMMAND_LINE
-// CHECK4: :[[@LINE-1]]:9: warning: 'MACRO_FROM_COMMAND_LINE' macro redefined
+// CHECK3: :[[@LINE-1]]:9: warning: 'MACRO_FROM_COMMAND_LINE' macro redefined

test/clang-tidy/list-clang-diagnostics.cpp

+// RUN: clang-tidy -checks='-*,clang-diagnostic-*' -list-checks 2>&1 | FileCheck -match-full-lines -implicit-check-not='{{.}}' %s
+// CHECK: Enabled checks:
+// CHECK: clang-diagnostic-#pragma-messages
+// CHECK: clang-diagnostic-#warnings
+// CHECK: clang-diagnostic-CFString-literal
+// CHECK: clang-diagnostic-IndependentClass-attribute
+// CHECK: clang-diagnostic-NSObject-attribute
+// CHECK: clang-diagnostic-absolute-value
+// CHECK: clang-diagnostic-abstract-final-class
+// CHECK: clang-diagnostic-abstract-vbase-init
+// CHECK: clang-diagnostic-address-of-array-temporary
+// CHECK: clang-diagnostic-address-of-packed-member
+// CHECK: clang-diagnostic-address-of-temporary
+// CHECK: clang-diagnostic-aligned-allocation-unavailable
+// CHECK: clang-diagnostic-alloca-with-align-alignof
+// CHECK: clang-diagnostic-ambiguous-delete
+// CHECK: clang-diagnostic-ambiguous-ellipsis
+// CHECK: clang-diagnostic-ambiguous-macro
+// CHECK: clang-diagnostic-ambiguous-member-template
+// CHECK: clang-diagnostic-analyzer-incompatible-plugin
+// CHECK: clang-diagnostic-anonymous-pack-parens
+// CHECK: clang-diagnostic-arc-bridge-casts-disallowed-in-nonarc
+// CHECK: clang-diagnostic-arc-maybe-repeated-use-of-weak
+// CHECK: clang-diagnostic-arc-non-pod-memaccess
+// CHECK: clang-diagnostic-arc-performSelector-leaks
+// CHECK: clang-diagnostic-arc-repeated-use-of-weak
+// CHECK: clang-diagnostic-arc-retain-cycles
+// CHECK: clang-diagnostic-arc-unsafe-retained-assign
+// CHECK: clang-diagnostic-array-bounds
+// CHECK: clang-diagnostic-array-bounds-pointer-arithmetic
+// CHECK: clang-diagnostic-asm-ignored-qualifier
+// CHECK: clang-diagnostic-asm-operand-widths
+// CHECK: clang-diagnostic-assign-enum
+// CHECK: clang-diagnostic-assume
+// CHECK: clang-diagnostic-at-protocol
+// CHECK: clang-diagnostic-atomic-memory-ordering
+// CHECK: clang-diagnostic-atomic-property-with-user-defined-accessor
+// CHECK: clang-diagnostic-attribute-packed-for-bitfield
+// CHECK: clang-diagnostic-auto-disable-vptr-sanitizer
+// CHECK: clang-diagnostic-auto-import
+// CHECK: clang-diagnostic-auto-storage-class
+// CHECK: clang-diagnostic-auto-var-id
+// CHECK: clang-diagnostic-availability
+// CHECK: clang-diagnostic-backend-plugin
+// CHECK: clang-diagnostic-backslash-newline-escape
+// CHECK: clang-diagnostic-bad-function-cast
+// CHECK: clang-diagnostic-bind-to-temporary-copy
+// CHECK: clang-diagnostic-bitfield-constant-conversion
+// CHECK: clang-diagnostic-bitfield-enum-conversion
+// CHECK: clang-diagnostic-bitfield-width
+// CHECK: clang-diagnostic-bitwise-op-parentheses
+// CHECK: clang-diagnostic-block-capture-autoreleasing
+// CHECK: clang-diagnostic-bool-conversion
+// CHECK: clang-diagnostic-braced-scalar-init
+// CHECK: clang-diagnostic-bridge-cast
+// CHECK: clang-diagnostic-builtin-macro-redefined
+// CHECK: clang-diagnostic-builtin-memcpy-chk-size
+// CHECK: clang-diagnostic-builtin-requires-header
+// CHECK: clang-diagnostic-c++-compat
+// CHECK: clang-diagnostic-c++11-compat
+// CHECK: clang-diagnostic-c++11-compat-deprecated-writable-strings
+// CHECK: clang-diagnostic-c++11-compat-reserved-user-defined-literal
+// CHECK: clang-diagnostic-c++11-extensions
+// CHECK: clang-diagnostic-c++11-extra-semi
+// CHECK: clang-diagnostic-c++11-inline-namespace
+// CHECK: clang-diagnostic-c++11-long-long
+// CHECK: clang-diagnostic-c++11-narrowing
+// CHECK: clang-diagnostic-c++14-binary-literal
+// CHECK: clang-diagnostic-c++14-extensions
+// CHECK: clang-diagnostic-c++17-compat-mangling
+// CHECK: clang-diagnostic-c++17-extensions
+// CHECK: clang-diagnostic-c++2a-compat
+// CHECK: clang-diagnostic-c++2a-extensions
+// CHECK: clang-diagnostic-c++98-c++11-c++14-c++17-compat
+// CHECK: clang-diagnostic-c++98-c++11-c++14-c++17-compat-pedantic
+// CHECK: clang-diagnostic-c++98-c++11-c++14-compat
+// CHECK: clang-diagnostic-c++98-c++11-c++14-compat-pedantic
+// CHECK: clang-diagnostic-c++98-c++11-compat
+// CHECK: clang-diagnostic-c++98-c++11-compat-pedantic
+// CHECK: clang-diagnostic-c++98-compat
+// CHECK: clang-diagnostic-c++98-compat-bind-to-temporary-copy
+// CHECK: clang-diagnostic-c++98-compat-local-type-template-args
+// CHECK: clang-diagnostic-c++98-compat-pedantic
+// CHECK: clang-diagnostic-c++98-compat-unnamed-type-template-args
+// CHECK: clang-diagnostic-c11-extensions
+// CHECK: clang-diagnostic-c99-compat
+// CHECK: clang-diagnostic-c99-extensions
+// CHECK: clang-diagnostic-cast-align
+// CHECK: clang-diagnostic-cast-calling-convention
+// CHECK: clang-diagnostic-cast-of-sel-type
+// CHECK: clang-diagnostic-cast-qual
+// CHECK: clang-diagnostic-char-subscripts
+// CHECK: clang-diagnostic-clang-cl-pch
+// CHECK: clang-diagnostic-class-varargs
+// CHECK: clang-diagnostic-comma
+// CHECK: clang-diagnostic-comment
+// CHECK: clang-diagnostic-compare-distinct-pointer-types
+// CHECK: clang-diagnostic-complex-component-init
+// CHECK: clang-diagnostic-conditional-type-mismatch
+// CHECK: clang-diagnostic-conditional-uninitialized
+// CHECK: clang-diagnostic-config-macros
+// CHECK: clang-diagnostic-constant-conversion
+// CHECK: clang-diagnostic-constant-logical-operand
+// CHECK: clang-diagnostic-constexpr-not-const
+// CHECK: clang-diagnostic-consumed
+// CHECK: clang-diagnostic-conversion
+// CHECK: clang-diagnostic-coroutine-missing-unhandled-exception
+// CHECK: clang-diagnostic-covered-switch-default
+// CHECK: clang-diagnostic-cstring-format-directive
+// CHECK: clang-diagnostic-cuda-compat
+// CHECK: clang-diagnostic-custom-atomic-properties
+// CHECK: clang-diagnostic-dangling-else
+// CHECK: clang-diagnostic-dangling-field
+// CHECK: clang-diagnostic-dangling-initializer-list
+// CHECK: clang-diagnostic-date-time
+// CHECK: clang-diagnostic-dealloc-in-category
+// CHECK: clang-diagnostic-debug-compression-unavailable
+// CHECK: clang-diagnostic-declaration-after-statement
+// CHECK: clang-diagnostic-delegating-ctor-cycles
+// CHECK: clang-diagnostic-delete-incomplete
+// CHECK: clang-diagnostic-delete-non-virtual-dtor
+// CHECK: clang-diagnostic-deprecated
+// CHECK: clang-diagnostic-deprecated-attributes
+// CHECK: clang-diagnostic-deprecated-declarations
+// CHECK: clang-diagnostic-deprecated-dynamic-exception-spec
+// CHECK: clang-diagnostic-deprecated-implementations
+// CHECK: clang-diagnostic-deprecated-increment-bool
+// CHECK: clang-diagnostic-deprecated-objc-isa-usage
+// CHECK: clang-diagnostic-deprecated-objc-pointer-introspection
+// CHECK: clang-diagnostic-deprecated-objc-pointer-introspection-performSelector
+// CHECK: clang-diagnostic-deprecated-register
+// CHECK: clang-diagnostic-direct-ivar-access
+// CHECK: clang-diagnostic-disabled-macro-expansion
+// CHECK: clang-diagnostic-distributed-object-modifiers
+// CHECK: clang-diagnostic-division-by-zero
+// CHECK: clang-diagnostic-dll-attribute-on-redeclaration
+// CHECK: clang-diagnostic-dllexport-explicit-instantiation-decl
+// CHECK: clang-diagnostic-dllimport-static-field-def
+// CHECK: clang-diagnostic-documentation
+// CHECK: clang-diagnostic-documentation-deprecated-sync
+// CHECK: clang-diagnostic-documentation-html
+// CHECK: clang-diagnostic-documentation-pedantic
+// CHECK: clang-diagnostic-documentation-unknown-command
+// CHECK: clang-diagnostic-dollar-in-identifier-extension
+// CHECK: clang-diagnostic-double-promotion
+// CHECK: clang-diagnostic-duplicate-decl-specifier
+// CHECK: clang-diagnostic-duplicate-enum
+// CHECK: clang-diagnostic-duplicate-method-arg
+// CHECK: clang-diagnostic-duplicate-method-match
+// CHECK: clang-diagnostic-duplicate-protocol
+// CHECK: clang-diagnostic-dynamic-class-memaccess
+// CHECK: clang-diagnostic-dynamic-exception-spec
+// CHECK: clang-diagnostic-embedded-directive
+// CHECK: clang-diagnostic-empty-body
+// CHECK: clang-diagnostic-empty-decomposition
+// CHECK: clang-diagnostic-empty-translation-unit
+// CHECK: clang-diagnostic-encode-type
+// CHECK: clang-diagnostic-enum-compare
+// CHECK: clang-diagnostic-enum-compare-switch
+// CHECK: clang-diagnostic-enum-conversion
+// CHECK: clang-diagnostic-enum-too-large
+// CHECK: clang-diagnostic-exceptions
+// CHECK: clang-diagnostic-exit-time-destructors
+// CHECK: clang-diagnostic-expansion-to-defined
+// CHECK: clang-diagnostic-explicit-initialize-call
+// CHECK: clang-diagnostic-explicit-ownership-type
+// CHECK: clang-diagnostic-extended-offsetof
+// CHECK: clang-diagnostic-extern-c-compat
+// CHECK: clang-diagnostic-extern-initializer
+// CHECK: clang-diagnostic-extra
+// CHECK: clang-diagnostic-extra-qualification
+// CHECK: clang-diagnostic-extra-semi
+// CHECK: clang-diagnostic-extra-tokens
+// CHECK: clang-diagnostic-fallback
+// CHECK: clang-diagnostic-flag-enum
+// CHECK: clang-diagnostic-flexible-array-extensions
+// CHECK: clang-diagnostic-float-conversion
+// CHECK: clang-diagnostic-float-equal
+// CHECK: clang-diagnostic-float-overflow-conversion
+// CHECK: clang-diagnostic-float-zero-conversion
+// CHECK: clang-diagnostic-for-loop-analysis
+// CHECK: clang-diagnostic-format
+// CHECK: clang-diagnostic-format-extra-args
+// CHECK: clang-diagnostic-format-invalid-specifier
+// CHECK: clang-diagnostic-format-non-iso
+// CHECK: clang-diagnostic-format-nonliteral
+// CHECK: clang-diagnostic-format-pedantic
+// CHECK: clang-diagnostic-format-security
+// CHECK: clang-diagnostic-format-zero-length
+// CHECK: clang-diagnostic-four-char-constants
+// CHECK: clang-diagnostic-frame-larger-than=
+// CHECK: clang-diagnostic-function-def-in-objc-container
+// CHECK: clang-diagnostic-gcc-compat
+// CHECK: clang-diagnostic-global-constructors
+// CHECK: clang-diagnostic-gnu-alignof-expression
+// CHECK: clang-diagnostic-gnu-anonymous-struct
+// CHECK: clang-diagnostic-gnu-array-member-paren-init
+// CHECK: clang-diagnostic-gnu-auto-type
+// CHECK: clang-diagnostic-gnu-binary-literal
+// CHECK: clang-diagnostic-gnu-case-range
+// CHECK: clang-diagnostic-gnu-complex-integer
+// CHECK: clang-diagnostic-gnu-compound-literal-initializer
+// CHECK: clang-diagnostic-gnu-conditional-omitted-operand
+// CHECK: clang-diagnostic-gnu-designator
+// CHECK: clang-diagnostic-gnu-empty-initializer
+// CHECK: clang-diagnostic-gnu-empty-struct
+// CHECK: clang-diagnostic-gnu-flexible-array-initializer
+// CHECK: clang-diagnostic-gnu-flexible-array-union-member
+// CHECK: clang-diagnostic-gnu-folding-constant
+// CHECK: clang-diagnostic-gnu-imaginary-constant
+// CHECK: clang-diagnostic-gnu-include-next
+// CHECK: clang-diagnostic-gnu-label-as-value
+// CHECK: clang-diagnostic-gnu-redeclared-enum
+// CHECK: clang-diagnostic-gnu-statement-expression
+// CHECK: clang-diagnostic-gnu-static-float-init
+// CHECK: clang-diagnostic-gnu-string-literal-operator-template
+// CHECK: clang-diagnostic-gnu-union-cast
+// CHECK: clang-diagnostic-gnu-variable-sized-type-not-at-end
+// CHECK: clang-diagnostic-gnu-zero-line-directive
+// CHECK: clang-diagnostic-gnu-zero-variadic-macro-arguments
+// CHECK: clang-diagnostic-header-guard
+// CHECK: clang-diagnostic-header-hygiene
+// CHECK: clang-diagnostic-idiomatic-parentheses
+// CHECK: clang-diagnostic-ignored-attributes
+// CHECK: clang-diagnostic-ignored-optimization-argument
+// CHECK: clang-diagnostic-ignored-pragma-intrinsic
+// CHECK: clang-diagnostic-ignored-pragmas
+// CHECK: clang-diagnostic-ignored-qualifiers
+// CHECK: clang-diagnostic-implicit-atomic-properties
+// CHECK: clang-diagnostic-implicit-conversion-floating-point-to-bool
+// CHECK: clang-diagnostic-implicit-exception-spec-mismatch
+// CHECK: clang-diagnostic-implicit-fallthrough
+// CHECK: clang-diagnostic-implicit-fallthrough-per-function
+// CHECK: clang-diagnostic-implicit-function-declaration
+// CHECK: clang-diagnostic-implicit-int
+// CHECK: clang-diagnostic-implicit-retain-self
+// CHECK: clang-diagnostic-implicitly-unsigned-literal
+// CHECK: clang-diagnostic-import-preprocessor-directive-pedantic
+// CHECK: clang-diagnostic-inaccessible-base
+// CHECK: clang-diagnostic-include-next-absolute-path
+// CHECK: clang-diagnostic-include-next-outside-header
+// CHECK: clang-diagnostic-incompatible-exception-spec
+// CHECK: clang-diagnostic-incompatible-function-pointer-types
+// CHECK: clang-diagnostic-incompatible-library-redeclaration
+// CHECK: clang-diagnostic-incompatible-ms-struct
+// CHECK: clang-diagnostic-incompatible-pointer-types
+// CHECK: clang-diagnostic-incompatible-pointer-types-discards-qualifiers
+// CHECK: clang-diagnostic-incompatible-property-type
+// CHECK: clang-diagnostic-incompatible-sysroot
+// CHECK: clang-diagnostic-incomplete-implementation
+// CHECK: clang-diagnostic-incomplete-umbrella
+// CHECK: clang-diagnostic-inconsistent-dllimport
+// CHECK: clang-diagnostic-inconsistent-missing-destructor-override
+// CHECK: clang-diagnostic-inconsistent-missing-override
+// CHECK: clang-diagnostic-increment-bool
+// CHECK: clang-diagnostic-infinite-recursion
+// CHECK: clang-diagnostic-initializer-overrides
+// CHECK: clang-diagnostic-injected-class-name
+// CHECK: clang-diagnostic-inline-asm
+// CHECK: clang-diagnostic-inline-new-delete
+// CHECK: clang-diagnostic-instantiation-after-specialization
+// CHECK: clang-diagnostic-int-conversion
+// CHECK: clang-diagnostic-int-to-pointer-cast
+// CHECK: clang-diagnostic-int-to-void-pointer-cast
+// CHECK: clang-diagnostic-integer-overflow
+// CHECK: clang-diagnostic-invalid-command-line-argument
+// CHECK: clang-diagnostic-invalid-constexpr
+// CHECK: clang-diagnostic-invalid-iboutlet
+// CHECK: clang-diagnostic-invalid-initializer-from-system-header
+// CHECK: clang-diagnostic-invalid-ios-deployment-target
+// CHECK: clang-diagnostic-invalid-noreturn
+// CHECK: clang-diagnostic-invalid-offsetof
+// CHECK: clang-diagnostic-invalid-or-nonexistent-directory
+// CHECK: clang-diagnostic-invalid-partial-specialization
+// CHECK: clang-diagnostic-invalid-pp-token
+// CHECK: clang-diagnostic-invalid-source-encoding
+// CHECK: clang-diagnostic-invalid-token-paste
+// CHECK: clang-diagnostic-jump-seh-finally
+// CHECK: clang-diagnostic-keyword-compat
+// CHECK: clang-diagnostic-keyword-macro
+// CHECK: clang-diagnostic-knr-promoted-parameter
+// CHECK: clang-diagnostic-language-extension-token
+// CHECK: clang-diagnostic-large-by-value-copy
+// CHECK: clang-diagnostic-literal-conversion
+// CHECK: clang-diagnostic-literal-range
+// CHECK: clang-diagnostic-local-type-template-args
+// CHECK: clang-diagnostic-logical-not-parentheses
+// CHECK: clang-diagnostic-logical-op-parentheses
+// CHECK: clang-diagnostic-long-long
+// CHECK: clang-diagnostic-macro-redefined
+// CHECK: clang-diagnostic-main
+// CHECK: clang-diagnostic-main-return-type
+// CHECK: clang-diagnostic-malformed-warning-check
+// CHECK: clang-diagnostic-many-braces-around-scalar-init
+// CHECK: clang-diagnostic-max-unsigned-zero
+// CHECK: clang-diagnostic-memsize-comparison
+// CHECK: clang-diagnostic-method-signatures
+// CHECK: clang-diagnostic-microsoft-anon-tag
+// CHECK: clang-diagnostic-microsoft-cast
+// CHECK: clang-diagnostic-microsoft-charize
+// CHECK: clang-diagnostic-microsoft-comment-paste
+// CHECK: clang-diagnostic-microsoft-const-init
+// CHECK: clang-diagnostic-microsoft-cpp-macro
+// CHECK: clang-diagnostic-microsoft-default-arg-redefinition
+// CHECK: clang-diagnostic-microsoft-end-of-file
+// CHECK: clang-diagnostic-microsoft-enum-forward-reference
+// CHECK: clang-diagnostic-microsoft-enum-value
+// CHECK: clang-diagnostic-microsoft-exception-spec
+// CHECK: clang-diagnostic-microsoft-exists
+// CHECK: clang-diagnostic-microsoft-explicit-constructor-call
+// CHECK: clang-diagnostic-microsoft-extra-qualification
+// CHECK: clang-diagnostic-microsoft-fixed-enum
+// CHECK: clang-diagnostic-microsoft-flexible-array
+// CHECK: clang-diagnostic-microsoft-goto
+// CHECK: clang-diagnostic-microsoft-include
+// CHECK: clang-diagnostic-microsoft-mutable-reference
+// CHECK: clang-diagnostic-microsoft-pure-definition
+// CHECK: clang-diagnostic-microsoft-redeclare-static
+// CHECK: clang-diagnostic-microsoft-sealed
+// CHECK: clang-diagnostic-microsoft-template
+// CHECK: clang-diagnostic-microsoft-union-member-reference
+// CHECK: clang-diagnostic-microsoft-unqualified-friend
+// CHECK: clang-diagnostic-microsoft-using-decl
+// CHECK: clang-diagnostic-microsoft-void-pseudo-dtor
+// CHECK: clang-diagnostic-mismatched-new-delete
+// CHECK: clang-diagnostic-mismatched-parameter-types
+// CHECK: clang-diagnostic-mismatched-return-types
+// CHECK: clang-diagnostic-mismatched-tags
+// CHECK: clang-diagnostic-missing-braces
+// CHECK: clang-diagnostic-missing-declarations
+// CHECK: clang-diagnostic-missing-exception-spec
+// CHECK: clang-diagnostic-missing-field-initializers
+// CHECK: clang-diagnostic-missing-method-return-type
+// CHECK: clang-diagnostic-missing-noescape
+// CHECK: clang-diagnostic-missing-noreturn
+// CHECK: clang-diagnostic-missing-prototype-for-cc
+// CHECK: clang-diagnostic-missing-prototypes
+// CHECK: clang-diagnostic-missing-selector-name
+// CHECK: clang-diagnostic-missing-sysroot
+// CHECK: clang-diagnostic-missing-variable-declarations
+// CHECK: clang-diagnostic-module-conflict
+// CHECK: clang-diagnostic-module-file-config-mismatch
+// CHECK: clang-diagnostic-module-file-extension
+// CHECK: clang-diagnostic-module-import-in-extern-c
+// CHECK: clang-diagnostic-modules-ambiguous-internal-linkage
+// CHECK: clang-diagnostic-modules-import-nested-redundant
+// CHECK: clang-diagnostic-msvc-not-found
+// CHECK: clang-diagnostic-multichar
+// CHECK: clang-diagnostic-multiple-move-vbase
+// CHECK: clang-diagnostic-nested-anon-types
+// CHECK: clang-diagnostic-new-returns-null
+// CHECK: clang-diagnostic-newline-eof
+// CHECK: clang-diagnostic-non-literal-null-conversion
+// CHECK: clang-diagnostic-non-modular-include-in-framework-module
+// CHECK: clang-diagnostic-non-modular-include-in-module
+// CHECK: clang-diagnostic-non-pod-varargs
+// CHECK: clang-diagnostic-non-virtual-dtor
+// CHECK: clang-diagnostic-nonnull
+// CHECK: clang-diagnostic-nonportable-include-path
+// CHECK: clang-diagnostic-nonportable-system-include-path
+// CHECK: clang-diagnostic-nonportable-vector-initialization
+// CHECK: clang-diagnostic-nsconsumed-mismatch
+// CHECK: clang-diagnostic-nsreturns-mismatch
+// CHECK: clang-diagnostic-null-arithmetic
+// CHECK: clang-diagnostic-null-character
+// CHECK: clang-diagnostic-null-conversion
+// CHECK: clang-diagnostic-null-dereference
+// CHECK: clang-diagnostic-null-pointer-arithmetic
+// CHECK: clang-diagnostic-nullability
+// CHECK: clang-diagnostic-nullability-completeness
+// CHECK: clang-diagnostic-nullability-completeness-on-arrays
+// CHECK: clang-diagnostic-nullability-declspec
+// CHECK: clang-diagnostic-nullability-extension
+// CHECK: clang-diagnostic-nullability-inferred-on-nested-type
+// CHECK: clang-diagnostic-nullable-to-nonnull-conversion
+// CHECK: clang-diagnostic-objc-autosynthesis-property-ivar-name-match
+// CHECK: clang-diagnostic-objc-circular-container
+// CHECK: clang-diagnostic-objc-designated-initializers
+// CHECK: clang-diagnostic-objc-forward-class-redefinition
+// CHECK: clang-diagnostic-objc-interface-ivars
+// CHECK: clang-diagnostic-objc-literal-compare
+// CHECK: clang-diagnostic-objc-literal-conversion
+// CHECK: clang-diagnostic-objc-macro-redefinition
+// CHECK: clang-diagnostic-objc-messaging-id
+// CHECK: clang-diagnostic-objc-method-access
+// CHECK: clang-diagnostic-objc-missing-property-synthesis
+// CHECK: clang-diagnostic-objc-missing-super-calls
+// CHECK: clang-diagnostic-objc-multiple-method-names
+// CHECK: clang-diagnostic-objc-noncopy-retain-block-property
+// CHECK: clang-diagnostic-objc-nonunified-exceptions
+// CHECK: clang-diagnostic-objc-property-implementation
+// CHECK: clang-diagnostic-objc-property-implicit-mismatch
+// CHECK: clang-diagnostic-objc-property-matches-cocoa-ownership-rule
+// CHECK: clang-diagnostic-objc-property-no-attribute
+// CHECK: clang-diagnostic-objc-property-synthesis
+// CHECK: clang-diagnostic-objc-protocol-method-implementation
+// CHECK: clang-diagnostic-objc-protocol-property-synthesis
+// CHECK: clang-diagnostic-objc-protocol-qualifiers
+// CHECK: clang-diagnostic-objc-readonly-with-setter-property
+// CHECK: clang-diagnostic-objc-redundant-literal-use
+// CHECK: clang-diagnostic-objc-root-class
+// CHECK: clang-diagnostic-objc-string-compare
+// CHECK: clang-diagnostic-objc-string-concatenation
+// CHECK: clang-diagnostic-objc-unsafe-perform-selector
+// CHECK: clang-diagnostic-odr
+// CHECK: clang-diagnostic-old-style-cast
+// CHECK: clang-diagnostic-opencl-unsupported-rgba
+// CHECK: clang-diagnostic-openmp-clauses
+// CHECK: clang-diagnostic-openmp-loop-form
+// CHECK: clang-diagnostic-openmp-target
+// CHECK: clang-diagnostic-option-ignored
+// CHECK: clang-diagnostic-out-of-line-declaration
+// CHECK: clang-diagnostic-over-aligned
+// CHECK: clang-diagnostic-overlength-strings
+// CHECK: clang-diagnostic-overloaded-shift-op-parentheses
+// CHECK: clang-diagnostic-overloaded-virtual
+// CHECK: clang-diagnostic-override-module
+// CHECK: clang-diagnostic-overriding-method-mismatch
+// CHECK: clang-diagnostic-overriding-t-option
+// CHECK: clang-diagnostic-packed
+// CHECK: clang-diagnostic-padded
+// CHECK: clang-diagnostic-parentheses
+// CHECK: clang-diagnostic-parentheses-equality
+// CHECK: clang-diagnostic-pass-failed
+// CHECK: clang-diagnostic-pch-date-time
+// CHECK: clang-diagnostic-pedantic
+// CHECK: clang-diagnostic-pedantic-core-features
+// CHECK: clang-diagnostic-pessimizing-move
+// CHECK: clang-diagnostic-pointer-arith
+// CHECK: clang-diagnostic-pointer-bool-conversion
+// CHECK: clang-diagnostic-pointer-sign
+// CHECK: clang-diagnostic-pointer-type-mismatch
+// CHECK: clang-diagnostic-potentially-evaluated-expression
+// CHECK: clang-diagnostic-pragma-clang-attribute
+// CHECK: clang-diagnostic-pragma-once-outside-header
+// CHECK: clang-diagnostic-pragma-pack
+// CHECK: clang-diagnostic-pragma-pack-suspicious-include
+// CHECK: clang-diagnostic-pragma-system-header-outside-header
+// CHECK: clang-diagnostic-pragmas
+// CHECK: clang-diagnostic-predefined-identifier-outside-function
+// CHECK: clang-diagnostic-private-extern
+// CHECK: clang-diagnostic-private-header
+// CHECK: clang-diagnostic-private-module
+// CHECK: clang-diagnostic-profile-instr-missing
+// CHECK: clang-diagnostic-profile-instr-out-of-date
+// CHECK: clang-diagnostic-profile-instr-unprofiled
+// CHECK: clang-diagnostic-property-access-dot-syntax
+// CHECK: clang-diagnostic-property-attribute-mismatch
+// CHECK: clang-diagnostic-protocol
+// CHECK: clang-diagnostic-protocol-property-synthesis-ambiguity
+// CHECK: clang-diagnostic-qualified-void-return-type
+// CHECK: clang-diagnostic-range-loop-analysis
+// CHECK: clang-diagnostic-readonly-iboutlet-property
+// CHECK: clang-diagnostic-receiver-expr
+// CHECK: clang-diagnostic-receiver-forward-class
+// CHECK: clang-diagnostic-redeclared-class-member
+// CHECK: clang-diagnostic-redundant-move
+// CHECK: clang-diagnostic-register
+// CHECK: clang-diagnostic-reinterpret-base-class
+// CHECK: clang-diagnostic-reorder
+// CHECK: clang-diagnostic-requires-super-attribute
+// CHECK: clang-diagnostic-reserved-id-macro
+// CHECK: clang-diagnostic-reserved-user-defined-literal
+// CHECK: clang-diagnostic-retained-language-linkage
+// CHECK: clang-diagnostic-return-stack-address
+// CHECK: clang-diagnostic-return-type
+// CHECK: clang-diagnostic-return-type-c-linkage
+// CHECK: clang-diagnostic-rtti-for-exceptions
+// CHECK: clang-diagnostic-section
+// CHECK: clang-diagnostic-selector
+// CHECK: clang-diagnostic-selector-type-mismatch
+// CHECK: clang-diagnostic-self-assign
+// CHECK: clang-diagnostic-self-assign-field
+// CHECK: clang-diagnostic-self-move
+// CHECK: clang-diagnostic-semicolon-before-method-body
+// CHECK: clang-diagnostic-sentinel
+// CHECK: clang-diagnostic-serialized-diagnostics
+// CHECK: clang-diagnostic-shadow
+// CHECK: clang-diagnostic-shadow-field
+// CHECK: clang-diagnostic-shadow-field-in-constructor
+// CHECK: clang-diagnostic-shadow-field-in-constructor-modified
+// CHECK: clang-diagnostic-shadow-ivar
+// CHECK: clang-diagnostic-shadow-uncaptured-local
+// CHECK: clang-diagnostic-shift-count-negative
+// CHECK: clang-diagnostic-shift-count-overflow
+// CHECK: clang-diagnostic-shift-negative-value
+// CHECK: clang-diagnostic-shift-op-parentheses
+// CHECK: clang-diagnostic-shift-overflow
+// CHECK: clang-diagnostic-shift-sign-overflow
+// CHECK: clang-diagnostic-shorten-64-to-32
+// CHECK: clang-diagnostic-sign-compare
+// CHECK: clang-diagnostic-sign-conversion
+// CHECK: clang-diagnostic-signed-enum-bitfield
+// CHECK: clang-diagnostic-sizeof-array-argument
+// CHECK: clang-diagnostic-sizeof-array-decay
+// CHECK: clang-diagnostic-sizeof-pointer-memaccess
+// CHECK: clang-diagnostic-slash-u-filename
+// CHECK: clang-diagnostic-sometimes-uninitialized
+// CHECK: clang-diagnostic-source-uses-openmp
+// CHECK: clang-diagnostic-spir-compat
+// CHECK: clang-diagnostic-static-float-init
+// CHECK: clang-diagnostic-static-in-inline
+// CHECK: clang-diagnostic-static-inline-explicit-instantiation
+// CHECK: clang-diagnostic-static-local-in-inline
+// CHECK: clang-diagnostic-static-self-init
+// CHECK: clang-diagnostic-strict-prototypes
+// CHECK: clang-diagnostic-strict-selector-match
+// CHECK: clang-diagnostic-string-compare
+// CHECK: clang-diagnostic-string-conversion
+// CHECK: clang-diagnostic-string-plus-char
+// CHECK: clang-diagnostic-string-plus-int
+// CHECK: clang-diagnostic-strlcpy-strlcat-size
+// CHECK: clang-diagnostic-strncat-size
+// CHECK: clang-diagnostic-super-class-method-mismatch
+// CHECK: clang-diagnostic-switch
+// CHECK: clang-diagnostic-switch-bool
+// CHECK: clang-diagnostic-switch-enum
+// CHECK: clang-diagnostic-sync-fetch-and-nand-semantics-changed
+// CHECK: clang-diagnostic-tautological-compare
+// CHECK: clang-diagnostic-tautological-constant-out-of-range-compare
+// CHECK: clang-diagnostic-tautological-overlap-compare
+// CHECK: clang-diagnostic-tautological-pointer-compare
+// CHECK: clang-diagnostic-tautological-undefined-compare
+// CHECK: clang-diagnostic-tautological-unsigned-enum-zero-compare
+// CHECK: clang-diagnostic-tautological-unsigned-zero-compare
+// CHECK: clang-diagnostic-tentative-definition-incomplete-type
+// CHECK: clang-diagnostic-thread-safety-analysis
+// CHECK: clang-diagnostic-thread-safety-attributes
+// CHECK: clang-diagnostic-thread-safety-beta
+// CHECK: clang-diagnostic-thread-safety-negative
+// CHECK: clang-diagnostic-thread-safety-precise
+// CHECK: clang-diagnostic-thread-safety-reference
+// CHECK: clang-diagnostic-thread-safety-verbose
+// CHECK: clang-diagnostic-trigraphs
+// CHECK: clang-diagnostic-type-safety
+// CHECK: clang-diagnostic-typedef-redefinition
+// CHECK: clang-diagnostic-typename-missing
+// CHECK: clang-diagnostic-unable-to-open-stats-file
+// CHECK: clang-diagnostic-unavailable-declarations
+// CHECK: clang-diagnostic-undeclared-selector
+// CHECK: clang-diagnostic-undef
+// CHECK: clang-diagnostic-undefined-bool-conversion
+// CHECK: clang-diagnostic-undefined-func-template
+// CHECK: clang-diagnostic-undefined-inline
+// CHECK: clang-diagnostic-undefined-internal
+// CHECK: clang-diagnostic-undefined-internal-type
+// CHECK: clang-diagnostic-undefined-reinterpret-cast
+// CHECK: clang-diagnostic-undefined-var-template
+// CHECK: clang-diagnostic-unevaluated-expression
+// CHECK: clang-diagnostic-unguarded-availability
+// CHECK: clang-diagnostic-unguarded-availability-new
+// CHECK: clang-diagnostic-unicode
+// CHECK: clang-diagnostic-unicode-whitespace
+// CHECK: clang-diagnostic-uninitialized
+// CHECK: clang-diagnostic-unknown-argument
+// CHECK: clang-diagnostic-unknown-attributes
+// CHECK: clang-diagnostic-unknown-escape-sequence
+// CHECK: clang-diagnostic-unknown-pragmas
+// CHECK: clang-diagnostic-unknown-sanitizers
+// CHECK: clang-diagnostic-unknown-warning-option
+// CHECK: clang-diagnostic-unnamed-type-template-args
+// CHECK: clang-diagnostic-unneeded-internal-declaration
+// CHECK: clang-diagnostic-unneeded-member-function
+// CHECK: clang-diagnostic-unreachable-code
+// CHECK: clang-diagnostic-unreachable-code-break
+// CHECK: clang-diagnostic-unreachable-code-loop-increment
+// CHECK: clang-diagnostic-unreachable-code-return
+// CHECK: clang-diagnostic-unsequenced
+// CHECK: clang-diagnostic-unsupported-abs
+// CHECK: clang-diagnostic-unsupported-availability-guard
+// CHECK: clang-diagnostic-unsupported-cb
+// CHECK: clang-diagnostic-unsupported-dll-base-class-template
+// CHECK: clang-diagnostic-unsupported-friend
+// CHECK: clang-diagnostic-unsupported-gpopt
+// CHECK: clang-diagnostic-unsupported-nan
+// CHECK: clang-diagnostic-unsupported-visibility
+// CHECK: clang-diagnostic-unusable-partial-specialization
+// CHECK: clang-diagnostic-unused-command-line-argument
+// CHECK: clang-diagnostic-unused-comparison
+// CHECK: clang-diagnostic-unused-const-variable
+// CHECK: clang-diagnostic-unused-exception-parameter
+// CHECK: clang-diagnostic-unused-function
+// CHECK: clang-diagnostic-unused-getter-return-value
+// CHECK: clang-diagnostic-unused-label
+// CHECK: clang-diagnostic-unused-lambda-capture
+// CHECK: clang-diagnostic-unused-local-typedef
+// CHECK: clang-diagnostic-unused-macros
+// CHECK: clang-diagnostic-unused-member-function
+// CHECK: clang-diagnostic-unused-parameter
+// CHECK: clang-diagnostic-unused-private-field
+// CHECK: clang-diagnostic-unused-property-ivar
+// CHECK: clang-diagnostic-unused-result
+// CHECK: clang-diagnostic-unused-template
+// CHECK: clang-diagnostic-unused-value
+// CHECK: clang-diagnostic-unused-variable
+// CHECK: clang-diagnostic-unused-volatile-lvalue
+// CHECK: clang-diagnostic-used-but-marked-unused
+// CHECK: clang-diagnostic-user-defined-literals
+// CHECK: clang-diagnostic-user-defined-warnings
+// CHECK: clang-diagnostic-varargs
+// CHECK: clang-diagnostic-variadic-macros
+// CHECK: clang-diagnostic-vec-elem-size
+// CHECK: clang-diagnostic-vector-conversion
+// CHECK: clang-diagnostic-vexing-parse
+// CHECK: clang-diagnostic-visibility
+// CHECK: clang-diagnostic-vla
+// CHECK: clang-diagnostic-vla-extension
+// CHECK: clang-diagnostic-void-ptr-dereference
+// CHECK: clang-diagnostic-weak-template-vtables
+// CHECK: clang-diagnostic-weak-vtables
+// CHECK: clang-diagnostic-writable-strings
+// CHECK: clang-diagnostic-zero-as-null-pointer-constant
+// CHECK: clang-diagnostic-zero-length-array
+// CHECK-NOT: {{.}}

test/clang-tidy/misc-suspicious-semicolon-fail.cpp

 // RUN: clang-tidy %s -checks="-*,misc-suspicious-semicolon" -- -DERROR 2>&1 \
 // RUN:   | FileCheck %s -check-prefix=CHECK-ERROR \
 // RUN:       -implicit-check-not="{{warning|error}}:"
-// RUN: clang-tidy %s -checks="-*,misc-suspicious-semicolon,clang-diagnostic*" \
-// RUN:    -- -DWERROR -Wno-everything -Werror=unused-variable 2>&1 \
+// RUN: not clang-tidy %s -checks="-*,misc-suspicious-semicolon,clang-diagnostic-unused-variable" \
+// RUN:   -warnings-as-errors=clang-diagnostic-unused-variable -- -DWERROR 2>&1 \
 // RUN:   | FileCheck %s -check-prefix=CHECK-WERROR \
 // RUN:       -implicit-check-not="{{warning|error}}:"
 
 // Note: This test verifies that, the checker does not emit any warning for
 //       files that do not compile.
 
 bool g();
 
 void f() {
   if (g());
   // CHECK-WERROR: :[[@LINE-1]]:11: warning: potentially unintended semicolon [misc-suspicious-semicolon]
 #if ERROR
   int a
   // CHECK-ERROR: :[[@LINE-1]]:8: error: expected ';' at end of declaration [clang-diagnostic-error]
 #elif WERROR
   int a;
-  // CHECK-WERROR: :[[@LINE-1]]:7: error: unused variable 'a' [clang-diagnostic-unused-variable]
+  // CHECK-WERROR: :[[@LINE-1]]:7: error: unused variable 'a' [clang-diagnostic-unused-variable,-warnings-as-errors]
 #else
 #error "One of ERROR or WERROR should be defined.
 #endif
 }

test/clang-tidy/validate-check-names.cpp

 // Check names may only contain alphanumeric characters, '-', '_', and '.'.
-// RUN: clang-tidy -checks=* -list-checks | grep '^    ' | cut -b5- | not grep -v '^[a-zA-Z0-9_.\-]\+$'
+// RUN: clang-tidy -checks=*,-clang-diagnostic* -list-checks | grep '^    ' | cut -b5- | not grep -v '^[a-zA-Z0-9_.\-]\+$'

test/clang-tidy/warning-check-aliases.cpp

+// RUN: clang-tidy %s -checks='-*,clang-diagnostic-exceptions' -- 2>&1 | FileCheck -implicit-check-not='{{warning:|error:}}' %s
+// RUN: clang-tidy %s -checks='-*,cert-err54-cpp' -- 2>&1 | FileCheck -implicit-check-not='{{warning:|error:}}' -check-prefix=CHECK2 %s
+// RUN: clang-tidy %s -- 2>&1 | FileCheck -allow-empty -implicit-check-not='{{warning:|error:}}' -check-prefix=CHECK3 %s
+
+class B {};
+class D : public B {};
+
+void f() {
+  try {
+
+  } catch (B &X) {
+
+  } catch (D &Y) {
+  }
+}
+
+//CHECK: :13:12: warning: exception of type 'D &' will be caught by earlier handler [clang-diagnostic-exceptions]
+//CHECK: :11:12: note: for type 'B &'
+
+//CHECK2: :13:12: warning: exception of type 'D &' will be caught by earlier handler [cert-err54-cpp]
+//CHECK2: :11:12: note: for type 'B &'

test/clang-tidy/werrors-diagnostics.cpp

-// RUN: clang-tidy %s -checks='-*,llvm-namespace-comment,clang-diagnostic*' \
-// RUN:   -- -Wunused-variable 2>&1 \
+// RUN: clang-tidy %s -checks='-*,llvm-namespace-comment,clang-diagnostic-unused-variable' -- 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=CHECK-WARN -implicit-check-not='{{warning|error}}:'
-// RUN: not clang-tidy %s -checks='-*,llvm-namespace-comment,clang-diagnostic*' \
-// RUN:   -warnings-as-errors='clang-diagnostic*' -- -Wunused-variable 2>&1 \
+// RUN: not clang-tidy %s -checks='-*,llvm-namespace-comment,clang-diagnostic-unused-variable' \
+// RUN:   -warnings-as-errors='clang-diagnostic*' -- 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=CHECK-WERR -implicit-check-not='{{warning|error}}:'
-// RUN: not clang-tidy %s -checks='-*,llvm-namespace-comment,clang-diagnostic*' \
-// RUN:   -warnings-as-errors='clang-diagnostic*' -quiet -- -Wunused-variable 2>&1 \
+// RUN: not clang-tidy %s -checks='-*,llvm-namespace-comment,clang-diagnostic-unused-variable' \
+// RUN:   -warnings-as-errors='clang-diagnostic*' -quiet -- 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=CHECK-WERR-QUIET -implicit-check-not='{{warning|error}}:'
 
 void f() { int i; }
 // CHECK-WARN: warning: unused variable 'i' [clang-diagnostic-unused-variable]
 // CHECK-WERR: error: unused variable 'i' [clang-diagnostic-unused-variable,-warnings-as-errors]
 // CHECK-WERR-QUIET: error: unused variable 'i' [clang-diagnostic-unused-variable,-warnings-as-errors]
 
 // CHECK-WARN-NOT: treated as
 // CHECK-WERR: 1 warning treated as error
 // CHECK-WERR-QUIET-NOT: treated as