[clang-tidy] avoid reserved names check

[NorenaLeonetti]

Summary

Based on CERT-DCL51-CPP

[Eugene.Zelenko]

docs/clang-tidy/checks/cert-dcl51-cpp.rst

34

Will be good idea to mention that this is Clang warnings. Please also make consistent indentation for lists here and above.

[Prazek]

clang-tidy/cert/AvoidReservedNamesCheck.cpp

23

Is this clang formatted? It will be probably better to have
it in multiple lines since it won't change (only from standard to standard)

[aaron.ballman]

clang-tidy/cert/AvoidReservedNamesCheck.cpp

23

I'm a bit worried about this list getting out of sync with the frontend. @alexfh, do you have any reservations about using TokenKinds.def from the frontend to generate this list?

130

Might as well not name the MacroDirective argument here and below, since it's unused.

142

You can use isInvalid() here instead of negating isValid().

153–154

I am a bit concerned about the performance of this check -- there are bound to be a *lot* of named declarations in a source file. Performance numbers would be helpful.

163

isInvalid()

177

How about: "identifiers containing double underscores are reserved to the implementation"

179

Similarly: "names declared at global scope that start with an underscore are reserved to the implementation"

181

Similarly: "identifiers that begin with an underscore followed by an uppercase letter are reserved to the implementation"

189

const auto *

201

Instead of using the plural form, I'd use singular:

"do not use a macro name that is identical to a keyword or an attribute"

Note, I think we want to have an escape hatch for macro names that are identical to a keyword when the replacement list is is the name of the keyword with underscores removed. e.g.,

#define inline __inline
#define const const

docs/clang-tidy/checks/cert-dcl51-cpp.rst

7–8

Perhaps:

This check will catch the following errors due to the names being reserved to the implementation:

test/clang-tidy/Inputs/Headers/sha.h

1 ↗

(On Diff #101200)

I'm not keen on the name of this header file. Can you rename it something more like "dcl51.h"?

[alexfh]

clang-tidy/cert/AvoidReservedNamesCheck.cpp

23

If I'm not missing anything, this should be pretty straightforward for the names listed there. However, things like optimize_for_synchronized are not yet mentioned in TokenKinds.def. Options are to add them there or extend the list in the check.

[NorenaLeonetti]

This comment was removed by NorenaLeonetti.

clang-tidy/cert/AvoidReservedNamesCheck.cpp

23

Thanks for the advice, I changed the list to use TokenKinds.def. However, I'm not really aware what you mean by the "thing like optimize_for_synchronized ". Where can I find the others that are missing and what are these?

153–154

I checked the performance with two configurations.

First like this:

-checks=-*,cert-dcl51-cpp,modernize-unary-static-assert

The result:

real    49m53.389s
user    290m45.508s
sys     7m45.504s

Then like this:

-checks=-*,modernize-unary-static-assert

The result:

real    48m45.531s
user    284m33.860s
sys     7m33.480s

[alexfh]

clang-tidy/cert/AvoidReservedNamesCheck.cpp

23

However, I'm not really aware what you mean by the "thing like optimize_for_synchronized ". Where can I find the others that are missing and what are these?

Well, the hard-coded list in the first version of your patch included "optimize_for_synchronized". I have no idea what is that (google says it's from the transactional memory TS) and I also don't know if any other entries from that original list are missing from TokenKinds.def. You might want to dump the list from the new version of your patch and compare it with the old one. If something is missing, it makes sense adding it to the list (either here or maybe even to TokenKinds.def, if nobody has concerns about that).

58–59

How about a range for loop here?

60–63

I'd avoid creating new strings and use something like this instead: x.endswith(y) && (x.length() == y.length() || (x.length() == y.length() + 2 && x.startswith("__"))).

[NorenaLeonetti]

clang-tidy/cert/AvoidReservedNamesCheck.cpp

23

I added the attribute specifier sequence attributes to the first list since the standard highlighted to avoid attribute tokens: "A translation unit shall not #define or #undef names lexically identical to keywords, to the identifiers listed in Table 3, or to the attribute-tokens described in 7.6.". I'm not sure if these belong to TokenKinds.def or there's a reason why these have been left out, so I just listed them here.

[alexfh]

clang-tidy/cert/AvoidReservedNamesCheck.cpp

60–63

This condition is not equivalent to the one you had before. It doesn't ensure the prefix is "__".

BTW, should the check complain on all names starting with __? [global.names] says:
"— Each name that contains a double underscore _ _ or begins with an underscore followed by an uppercase letter (2.12) is reserved to the implementation for any use.
— Each name that begins with an underscore is reserved to the implementation for use as a name in the global namespace."

[NorenaLeonetti]

clang-tidy/cert/AvoidReservedNamesCheck.cpp

60–63

You're right, the check should warn for global names starting with "__" but this part is based on the exception:
"For compatibility with other compiler vendors or language standard modes, it is acceptable to create a macro identifier that is the same as a reserved identifier so long as the behaviour is semantically identical, as in this example.
// Sometimes generated by configuration tools such as autoconf
#define const const

// Allowed compilers with semantically equivalent extension behaviour
#define inline __inline
"

[alexfh]

clang-tidy/cert/AvoidReservedNamesCheck.cpp

23

I'd use StringSet<> for faster lookups and maybe also wrap this in a function:

static bool IsKeyword(StringRef Name) {
  const static StringSet<> Keywords = {
    ...
  };
  return Keywords.count(Name) != 0;
}

69–76

The code is more confusing than it could be. This also doesn't do what it claims to do. IIUC, it will accept macro definitions like #define const const const const. Instead, I'd suggest a less "clever" code:

const auto &Tokens = MD->getMacroInfo()->tokens();
return Tokens.size() == 1 && identical(MNT.getIdentifierInfo()->getName(), Tokens.front().getIdentifierInfo()->getName());

79

Please add a comment about this exception, maybe with an example of what it allows.

109

nit: Function names are better when they are verbs, e.g. here checkDeclNameIsReserved would be clearer, IMHO. Same applies to macroNameIsKeywordCheck below and macroNameCheck above.

133

It's trivial to make this function iterative without sacrificing readability:

const DeclContext *DC = D->getDeclContext();
while (const auto *NS = dyn_cast<NamespaceDecl>(DC)) {
  if (!NS->isAnonymousNamespace())
      return false;
  DC = NS->getDeclContext();
}
return DC->isTranslationUnit();

clang-tidy/cert/AvoidReservedNamesCheck.h

33

nit: Please add an empty line above (or just clang-format the code).

test/clangd/definitions.test

141 ↗

(On Diff #108031)

Unrelated change?

[aaron.ballman]

clang-tidy/cert/AvoidReservedNamesCheck.cpp

23

While it's not incorrect to list the attribute names, it's also a bit inconsistent to do it. C++17 defines a list of zombie names, there's also "A translation unit that includes a standard library header shall not #define or #undef names declared in any standard library header.", etc. It's a bit strange that attributes get more special treatment than names declared in standard library headers. However, I'm not opposed to listing the attribute names if you think this is better.

I think we should just drop non-standard attributes (including ones from TSes), like optimize_for_synchronized, especially when our implementation does not implement those attributes.

[alexfh]

clang-tidy/cert/AvoidReservedNamesCheck.cpp

63–67

There's a more common and less tautological equivalent for

if (X) return true;
return false

It's return X;.

79

1. There's a typo in the comment ("definte").
2. It doesn't make it clear _why_ these constructs are allowed. A more thorough declaration would be helpful.

96–99

I'd suggest restructuring the code to avoid an unnecessary lookup (and make it clear both "var" and "label" aren't expected), e.g.:

const auto *ND = Result.Nodes.getNodeAs<NamedDecl>("var");

if (!ND) {
  if (const auto *L = Result.Nodes.getNodeAs<LabelStmt>("label"))
    ND = L->getDecl();
}

docs/clang-tidy/checks/cert-dcl51-cpp.rst

31

s/Clang checks/Clang diagnostics/

clang-tidy/cert/AvoidReservedNamesCheck.h

+//===--- AvoidReservedNamesCheck.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_CERT_AVOID_RESERVED_NAMES_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_AVOID_RESERVED_NAMES_H
+
+#include "../ClangTidy.h"
+
+namespace clang {
+namespace tidy {
+namespace cert {
+
+/// This check will catch names declared or defined as a reserved identifier.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/cert-dcl51-cpp.html
+class AvoidReservedNamesCheck : public ClangTidyCheck {
+public:
+  AvoidReservedNamesCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  void checkDeclNameIsReserved(StringRef Name, SourceLocation Location,
+                               bool IsGlobal);
+  void checkMacroNameIsKeyword(const Token &MacroNameTok);
+  void registerPPCallbacks(CompilerInstance &Compiler) override;
+
+private:
+  bool isInGlobalNamespace(const Decl *D);
+};
+
+} // namespace cert
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_AVOID_RESERVED_NAMES_H

clang-tidy/cert/AvoidReservedNamesCheck.cpp

+//===--- AvoidReservedNamesCheck.cpp - clang-tidy--------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "AvoidReservedNamesCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Frontend/CompilerInstance.h"
+#include "clang/Lex/PPCallbacks.h"
+#include "clang/Lex/Preprocessor.h"
+#include <algorithm>
+
+using namespace clang::ast_matchers;
+
+namespace {
+static bool IsKeyword(StringRef Name) {
+  const static llvm::StringSet<> Keywords = {
+#define KEYWORD(X, Y) #X,
+#define CXX_KEYWORD_OPERATOR(X, Y) #X,
+#define CXX11_KEYWORD(X, Y) #X,
+#define CONCEPTS_KEYWORD(X) #X,
+#include "clang/Basic/TokenKinds.def"
+      "noreturn",
+      "carries_dependency",
+      "deprecated",
+      "fallthrough",
+      "nodiscard",
+      "maybe_unused",
+      "optimize_for_synchronized"};
+  return Keywords.count(Name) != 0;
+}
+} // namespace
+
+namespace clang {
+namespace tidy {
+namespace cert {
+
+namespace {
+class AvoidReservedNamesPPCallbacks : public PPCallbacks {
+public:
+  AvoidReservedNamesPPCallbacks(Preprocessor *PP,
+                                AvoidReservedNamesCheck *Check)
+      : PP(PP), Check(Check) {}
+
+  void MacroDefined(const Token &MacroNameTok,
+                    const MacroDirective *MD) override {
+    checkMacroName(MacroNameTok, MD);
+  }
+  void MacroUndefined(const Token &MacroNameTok, const MacroDefinition &,
+                      const MacroDirective *MD) override {
+    checkMacroName(MacroNameTok, MD);
+  }
+
+private:
+  Preprocessor *PP;
+  AvoidReservedNamesCheck *Check;
+  bool identical(const StringRef Name, const StringRef Alias) {
+    if (Name == Alias ||
+        (Alias.endswith(Name) && Alias.size() == (Name.size() + 2) &&
+         Alias.startswith("__")))
+      return true;
+    return false;
+  }
+  bool semanticallyEquivalent(const Token &MNT, const MacroDirective *MD) {
+    const auto &Tokens = MD->getMacroInfo()->tokens();
+    return Tokens.size() == 1 &&
+           identical(MNT.getIdentifierInfo()->getName(),
+                     Tokens.front().getIdentifierInfo()->getName());
+  }
+  void checkMacroName(const Token &MacroNameTok, const MacroDirective *MD) {
+    // Semantically equivalent:
+    // #define const const
+    // #definte const __const
+    if (MacroNameTok.getLocation().isInvalid() ||
+        PP->getSourceManager().isInSystemHeader(MacroNameTok.getLocation()) ||
+        semanticallyEquivalent(MacroNameTok, MD))
+      return;
+    Check->checkMacroNameIsKeyword(MacroNameTok);
+    Check->checkDeclNameIsReserved(MacroNameTok.getIdentifierInfo()->getName(),
+                                   MacroNameTok.getLocation(), true);
+  }
+};
+} // namespace
+
+void AvoidReservedNamesCheck::registerMatchers(MatchFinder *Finder) {
+  Finder->addMatcher(namedDecl().bind("var"), this);
+  Finder->addMatcher(labelStmt().bind("label"), this);
+}
+
+void AvoidReservedNamesCheck::check(const MatchFinder::MatchResult &Result) {
+  const auto *ND = Result.Nodes.getNodeAs<NamedDecl>("var");
+
+  if (const auto *L = Result.Nodes.getNodeAs<LabelStmt>("label"))
+    ND = L->getDecl();
+
+  if (ND->isImplicit())
+    return;
+
+  if (ND->getLocation().isInvalid() ||
+      Result.SourceManager->isInSystemHeader(ND->getLocation()) ||
+      !ND->getIdentifier())
+    return;
+
+  checkDeclNameIsReserved(ND->getName(), ND->getLocation(),
+                          isInGlobalNamespace(ND));
+}
+
+void AvoidReservedNamesCheck::checkDeclNameIsReserved(StringRef Name,
+                                                      SourceLocation Location,
+                                                      bool IsGlobal) {
+
+  if (Name.find("__") != StringRef::npos)
+    diag(Location, "identifiers containing double underscores are reserved to "
+                   "the implementation");
+  if (IsGlobal && Name.startswith("_"))
+    diag(Location, "do not use global names that start with an underscore");
+  if (Name.startswith("_") && Name.size() > 1 && std::isupper(Name[1]))
+    diag(Location, "identifiers that begin with an underscore followed by an "
+                   "uppercase letter are reserved to the implementation");
+}
+
+bool AvoidReservedNamesCheck::isInGlobalNamespace(const Decl *D) {
+  const DeclContext *DC = D->getDeclContext();
+  while (const auto *NS = dyn_cast<NamespaceDecl>(DC)) {
+    if (!NS->isAnonymousNamespace())
+        return false;
+    DC = NS->getDeclContext();
+  }
+  return DC->isTranslationUnit();
+}
+
+void AvoidReservedNamesCheck::checkMacroNameIsKeyword(
+    const Token &MacroNameTok) {
+  if (IsKeyword(MacroNameTok.getIdentifierInfo()->getName()))
+    diag(MacroNameTok.getLocation(), "do not use a macro name that is "
+                                     "identical to a keyword or an attribute");
+}
+
+void AvoidReservedNamesCheck::registerPPCallbacks(CompilerInstance &Compiler) {
+  Compiler.getPreprocessor().addPPCallbacks(
+      llvm::make_unique<AvoidReservedNamesPPCallbacks>(
+          &Compiler.getPreprocessor(), this));
+}
+
+} // namespace cert
+} // namespace tidy
+} // namespace clang

clang-tidy/cert/CERTTidyModule.cpp

 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
 #include "../google/UnnamedNamespaceInHeaderCheck.h"
 #include "../misc/MoveConstructorInitCheck.h"
 #include "../misc/NewDeleteOverloadsCheck.h"
 #include "../misc/NonCopyableObjects.h"
 #include "../misc/StaticAssertCheck.h"
 #include "../misc/ThrowByValueCatchByReferenceCheck.h"
+#include "AvoidReservedNamesCheck.h"
 #include "CommandProcessorCheck.h"
 #include "DontModifyStdNamespaceCheck.h"
 #include "FloatLoopCounter.h"
 #include "LimitedRandomnessCheck.h"
 #include "PostfixOperatorCheck.h"
 #include "SetLongJmpCheck.h"
 #include "StaticObjectExceptionCheck.h"
 #include "StrToNumCheck.h"
 #include "ThrownExceptionTypeCheck.h"
 #include "VariadicFunctionDefCheck.h"
 
 namespace clang {
 namespace tidy {
 namespace cert {
 
 class CERTModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     // C++ checkers
     // DCL
     CheckFactories.registerCheck<PostfixOperatorCheck>(
         "cert-dcl21-cpp");
     CheckFactories.registerCheck<VariadicFunctionDefCheck>("cert-dcl50-cpp");
+    CheckFactories.registerCheck<AvoidReservedNamesCheck>(
+        "cert-dcl51-cpp");
     CheckFactories.registerCheck<misc::NewDeleteOverloadsCheck>(
         "cert-dcl54-cpp");
     CheckFactories.registerCheck<DontModifyStdNamespaceCheck>(
         "cert-dcl58-cpp");
     CheckFactories.registerCheck<google::build::UnnamedNamespaceInHeaderCheck>(
         "cert-dcl59-cpp");
     // OOP
     CheckFactories.registerCheck<misc::MoveConstructorInitCheck>(

clang-tidy/cert/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS support)
 
 add_clang_library(clangTidyCERTModule
+  AvoidReservedNamesCheck.cpp
   CERTTidyModule.cpp
   CommandProcessorCheck.cpp
   DontModifyStdNamespaceCheck.cpp
   FloatLoopCounter.cpp
   LimitedRandomnessCheck.cpp
   PostfixOperatorCheck.cpp
   SetLongJmpCheck.cpp
   StaticObjectExceptionCheck.cpp

docs/ReleaseNotes.rst

 Improvements to clang-rename
 ----------------------------
 
 The improvements are...
 
 Improvements to clang-tidy
 --------------------------
 
+- New `cert-dcl51-cpp
+  <http://clang.llvm.org/extra/clang-tidy/checks/cert-dcl51-cpp.html>`_ check
+
+  Checks if a name is declared or defined with a reserved identifier.
+
 - Renamed checks to use correct term "implicit conversion" instead of "implicit
   cast" and modified messages and option names accordingly:
 
     * **performance-implicit-cast-in-loop** was renamed to
       `performance-implicit-conversion-in-loop
       <http://clang.llvm.org/extra/clang-tidy/checks/performance-implicit-conversion-in-loop.html>`_
     * **readability-implicit-bool-cast** was renamed to
       `readability-implicit-bool-conversion

docs/clang-tidy/checks/cert-dcl51-cpp.rst

+.. title:: clang-tidy - cert-dcl51-cpp
+
+cert-dcl51-cpp
+==============
+
+This check will catch the following errors due to the names being reserved to the implementation:
+    - Names in the global namespace should not start with an underscore.
+    - Names should not start with an underscore followed by an uppercase letter.
+    - Names should not contain a double underscore.
+    - Names defined in macros should not be identical to keywords.
+
+Here's an example using variables:
+
+.. code-block:: c++
+
+    #define override
+    // warning: macro name should not be identical to keyword
+
+    int _global_variable;
+    // warning: global name starts with an underscore
+
+    void function() {
+        int loval__variable;
+        // warning: name contains a double underscore
+    
+        int _Uppercase_variable;
+        // warning: name starts with an underscore followed by an uppercase letter
+    }
+
+This check does not include warnings for reserved macro names and 
+user defined literals, since Clang checks have already been written to those:
+    - Wreserved-id-macro
+    - Wuser-defined-literals
+
+This check corresponds to the CERT C++ Coding Standard rule
+`DCL51-CPP. Do not declare or define a reserved identifier
+<https://www.securecoding.cert.org/confluence/display/cplusplus/DCL51-CPP.+Do+not+declare+or+define+a+reserved+identifier>`_.
+

docs/clang-tidy/checks/list.rst

.. toctree::
    android-cloexec-socket
    boost-use-to-string
    bugprone-integer-division
    bugprone-suspicious-memset-usage
    bugprone-undefined-memory-manipulation
    cert-dcl03-c (redirects to misc-static-assert) <cert-dcl03-c>
    cert-dcl21-cpp
    cert-dcl50-cpp
+   cert-dcl51-cpps
    cert-dcl54-cpp (redirects to misc-new-delete-overloads) <cert-dcl54-cpp>
    cert-dcl58-cpp
    cert-dcl59-cpp (redirects to google-build-namespaces) <cert-dcl59-cpp>
    cert-env33-c
    cert-err09-cpp (redirects to misc-throw-by-value-catch-by-reference) <cert-err09-cpp>
    cert-err34-c
    cert-err52-cpp
    cert-err58-cpp

test/clang-tidy/Inputs/Headers/dcl51.h

+#pragma clang system_header
+
+namespace std {
+    #define override __override__
+    int __variable__;
+}

test/clang-tidy/cert-avoid-reserved-names.cpp

+// RUN: %check_clang_tidy %s cert-dcl51-cpp %t -- -- -I %S/Inputs/Headers
+
+#include "dcl51.h"
+
+#define _MACRO_NAME_
+// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: do not use global names that start with an underscore [cert-dcl51-cpp]      
+// CHECK-MESSAGES: :[[@LINE-2]]:9: warning: identifiers that begin with an underscore followed by an uppercase letter are reserved to the implementation [cert-dcl51-cpp]
+#define switch
+// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: do not use a macro name that is identical to a keyword or an attribute [cert-dcl51-cpp]
+#define else__if
+// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: identifiers containing double underscores are reserved to the implementation [cert-dcl51-cpp]
+
+int _global_variable;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: do not use global names that start with an underscore [cert-dcl51-cpp]      
+int _Upper;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: do not use global names that start with an underscore [cert-dcl51-cpp]
+// CHECK-MESSAGES: :[[@LINE-2]]:5: warning: identifiers that begin with an underscore followed by an uppercase letter are reserved to the implementation [cert-dcl51-cpp]       
+int __variable;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: do not use global names that start with an underscore [cert-dcl51-cpp]
+// CHECK-MESSAGES: :[[@LINE-2]]:5: warning: identifiers containing double underscores are reserved to the implementation [cert-dcl51-cpp]
+int some__variable;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: identifiers containing double underscores are reserved to the implementation [cert-dcl51-cpp]
+void fun__ction() {
+  int local__variable;
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:6: warning: identifiers containing double underscores are reserved to the implementation [cert-dcl51-cpp]
+// CHECK-MESSAGES: :[[@LINE-3]]:7: warning: identifiers containing double underscores are reserved to the implementation [cert-dcl51-cpp]
+void _Function() {
+  int _Case;
+}
+// CHECK-MESSAGES: :[[@LINE-3]]:6: warning: do not use global names that start with an underscore [cert-dcl51-cpp]
+// CHECK-MESSAGES: :[[@LINE-4]]:6: warning: identifiers that begin with an underscore followed by an uppercase letter are reserved to the implementation [cert-dcl51-cpp]
+// CHECK-MESSAGES: :[[@LINE-4]]:7: warning: identifiers that begin with an underscore followed by an uppercase letter are reserved to the implementation [cert-dcl51-cpp]    
+
+typedef int _Integer;
+// CHECK-MESSAGES: :[[@LINE-1]]:13: warning: do not use global names that start with an underscore [cert-dcl51-cpp]
+// CHECK-MESSAGES: :[[@LINE-2]]:13: warning: identifiers that begin with an underscore followed by an uppercase letter are reserved to the implementation [cert-dcl51-cpp]
+
+using _Char = char;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: do not use global names that start with an underscore [cert-dcl51-cpp]
+// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: identifiers that begin with an underscore followed by an uppercase letter are reserved to the implementation [cert-dcl51-cpp]
+
+template<int _Number> void _fun__ction();
+// CHECK-MESSAGES: :[[@LINE-1]]:14: warning: identifiers that begin with an underscore followed by an uppercase letter are reserved to the implementation [cert-dcl51-cpp]
+// CHECK-MESSAGES: :[[@LINE-2]]:28: warning: do not use global names that start with an underscore [cert-dcl51-cpp]
+// CHECK-MESSAGES: :[[@LINE-3]]:28: warning: identifiers containing double underscores are reserved to the implementation [cert-dcl51-cpp]
+
+enum _global_names {
+  _Variable = 1,
+  second__variable = 2
+};
+// CHECK-MESSAGES: :[[@LINE-4]]:6: warning: do not use global names that start with an underscore [cert-dcl51-cpp]
+// CHECK-MESSAGES: :[[@LINE-4]]:3: warning: identifiers that begin with an underscore followed by an uppercase letter are reserved to the implementation [cert-dcl51-cpp]
+// CHECK-MESSAGES: :[[@LINE-4]]:3: warning: identifiers containing double underscores are reserved to the implementation [cert-dcl51-cpp]
+
+void __Function() {
+  _label__:
+  if (true) {
+    goto _label__;
+  }
+}
+// CHECK-MESSAGES: :[[@LINE-6]]:6: warning: do not use global names that start with an underscore [cert-dcl51-cpp]
+// CHECK-MESSAGES: :[[@LINE-7]]:6: warning: identifiers containing double underscores are reserved to the implementation [cert-dcl51-cpp]
+// CHECK-MESSAGES: :[[@LINE-7]]:3: warning: identifiers containing double underscores are reserved to the implementation [cert-dcl51-cpp]
+
+namespace _reserved_namespace_ {
+  int _Variable;
+  struct _Struct_name {
+    void Fun__ction();
+  };
+}
+// CHECK-MESSAGES: :[[@LINE-6]]:11: warning: do not use global names that start with an underscore [cert-dcl51-cpp]
+// CHECK-MESSAGES: :[[@LINE-6]]:7: warning: identifiers that begin with an underscore followed by an uppercase letter are reserved to the implementation [cert-dcl51-cpp]
+// CHECK-MESSAGES: :[[@LINE-6]]:10: warning: identifiers that begin with an underscore followed by an uppercase letter are reserved to the implementation [cert-dcl51-cpp]
+// CHECK-MESSAGES: :[[@LINE-6]]:10: warning: identifiers containing double underscores are reserved to the implementation [cert-dcl51-cpp]
+
+namespace {
+  int _variable;
+  class _Classname {
+    void _Function();
+  };
+  namespace {
+    int _still_global;
+  }
+}
+// CHECK-MESSAGES: :[[@LINE-8]]:7: warning: do not use global names that start with an underscore [cert-dcl51-cpp]
+// CHECK-MESSAGES: :[[@LINE-8]]:9: warning: do not use global names that start with an underscore [cert-dcl51-cpp]
+// CHECK-MESSAGES: :[[@LINE-9]]:9: warning: identifiers that begin with an underscore followed by an uppercase letter are reserved to the implementation [cert-dcl51-cpp]
+// CHECK-MESSAGES: :[[@LINE-9]]:10: warning: identifiers that begin with an underscore followed by an uppercase letter are reserved to the implementation [cert-dcl51-cpp]
+// CHECK-MESSAGES: :[[@LINE-7]]:9: warning: do not use global names that start with an underscore [cert-dcl51-cpp]
+
+
+// Something that doesn't trigger the check:
+struct X {
+  int *begin();
+  int *end();
+};
+
+void function_for() {
+  X x;
+  for(int i : x) {
+    // Intentionally left empty.
+  }
+}
+
+#define MACRO_NAME
+#define override
+#define else_if
+
+#define const const
+#define inline __inline
+
+int some_variable;
+
+void fun_ction() {
+  int _local_lower_variable;
+}
+
+typedef int Integer;
+using Char = char;
+
+template<int Number> void function();
+
+enum my_enum {
+  variable = 1,
+  other_variable = 2
+};
+
+void Function() {
+  _label_:
+  if (true) {
+    goto _label_;
+  }
+}
+
+namespace my_space {
+  int _variable;
+  struct _struct_name_ {
+    void _function();
+  };
+  namespace {
+    int _my_variable;
+  }
+}
+
+namespace {
+  class Classname {
+    void _my_function();
+  };
+  bool operator==(Classname a, double b);
+}