LLVM and SPIRV-LLVM-Translator pull down #1083

Author: vladimirlaz

clang-tools-extra/clang-tidy/add_new_check.py

@@ -294,37 +294,87 @@ def write_test(module_path, module, check_name, test_extension):
 def update_checks_list(clang_tidy_path):
   docs_dir = os.path.join(clang_tidy_path, '../docs/clang-tidy/checks')
   filename = os.path.normpath(os.path.join(docs_dir, 'list.rst'))
+  # Read the content of the current list.rst file
   with open(filename, 'r') as f:
     lines = f.readlines()
+  # Get all existing docs
   doc_files = list(filter(lambda s: s.endswith('.rst') and s != 'list.rst',
                      os.listdir(docs_dir)))
   doc_files.sort()
 
-  def format_link(doc_file):
+  def has_auto_fix(check_name):
+    dirname, _, check_name = check_name.partition("-")
+
+    checkerCode = os.path.join(dirname, get_camel_name(check_name)) + ".cpp"
+
+    if not os.path.isfile(checkerCode):
+      return ""
+
+    with open(checkerCode) as f:
+      code = f.read()
+      if 'FixItHint' in code or "ReplacementText" in code or "fixit" in code:
+        # Some simple heuristics to figure out if a checker has an autofix or not.
+        return ' "Yes"'
+    return ""
+
+  def process_doc(doc_file):
     check_name = doc_file.replace('.rst', '')
+
     with open(os.path.join(docs_dir, doc_file), 'r') as doc:
       content = doc.read()
       match = re.search('.*:orphan:.*', content)
+
       if match:
-        return ''
+        # Orphan page, don't list it.
+        return '', ''
 
       match = re.search('.*:http-equiv=refresh: \d+;URL=(.*).html.*',
                         content)
-      if match:
-        return '   %(check)s (redirects to %(target)s) <%(check)s>\n' % {
-            'check': check_name,
-            'target': match.group(1)
-        }
-      return '   %s\n' % check_name
+      # Is it a redirect?
+      return check_name, match
+
+  def format_link(doc_file):
+    check_name, match = process_doc(doc_file)
+    if not match and check_name:
+      return '   `%(check)s <%(check)s.html>`_,%(autofix)s\n' % {
+        'check': check_name,
+        'autofix': has_auto_fix(check_name)
+      }
+    else:
+      return ''
+
+  def format_link_alias(doc_file):
+    check_name, match = process_doc(doc_file)
+    if match and check_name:
+      if match.group(1) == 'https://clang.llvm.org/docs/analyzer/checkers':
+        title_redirect = 'Clang Static Analyzer'
+      else:
+        title_redirect = match.group(1)
+      # The checker is just a redirect.
+      return '   `%(check)s <%(check)s.html>`_, `%(title)s <%(target)s.html>`_,%(autofix)s\n' % {
+        'check': check_name,
+        'target': match.group(1),
+        'title': title_redirect,
+        'autofix': has_auto_fix(match.group(1))
+      }
+    return ''
 
   checks = map(format_link, doc_files)
+  checks_alias = map(format_link_alias, doc_files)
 
   print('Updating %s...' % filename)
   with open(filename, 'w') as f:
     for line in lines:
       f.write(line)
-      if line.startswith('.. toctree::'):
+      if line.strip() == ".. csv-table::":
+        # We dump the checkers
+        f.write('   :header: "Name", "Offers fixes"\n\n')
         f.writelines(checks)
+        # and the aliases
+        f.write('\n\n')
+        f.write('.. csv-table:: Aliases..\n')
+        f.write('   :header: "Name", "Redirect", "Offers fixes"\n\n')
+        f.writelines(checks_alias)
         break
 
 
@@ -345,6 +395,11 @@ def write_docs(module_path, module, check_name):
        'underline': '=' * len(check_name_dashes)})
 
 
+def get_camel_name(check_name):
+  return ''.join(map(lambda elem: elem.capitalize(),
+                     check_name.split('-'))) + 'Check'
+
+
 def main():
   language_to_extension = {
       'c': 'c',
@@ -384,13 +439,11 @@ def main():
 
   module = args.module
   check_name = args.check
-
+  check_name_camel = get_camel_name(check_name)
   if check_name.startswith(module):
     print('Check name "%s" must not start with the module "%s". Exiting.' % (
         check_name, module))
     return
-  check_name_camel = ''.join(map(lambda elem: elem.capitalize(),
-                                 check_name.split('-'))) + 'Check'
   clang_tidy_path = os.path.dirname(sys.argv[0])
   module_path = os.path.join(clang_tidy_path, module)
 

clang-tools-extra/clang-tidy/bugprone/BranchCloneCheck.cpp

@@ -59,7 +59,8 @@ namespace bugprone {
 
 void BranchCloneCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
-      ifStmt(stmt().bind("if"),
+      ifStmt(unless(allOf(isConstexpr(), isInTemplateInstantiation())),
+             stmt().bind("if"),
              hasParent(stmt(unless(ifStmt(hasElse(equalsBoundNode("if")))))),
              hasElse(stmt().bind("else"))),
       this);

clang-tools-extra/clang-tidy/bugprone/BugproneTidyModule.cpp

@@ -36,6 +36,7 @@
 #include "NotNullTerminatedResultCheck.h"
 #include "ParentVirtualCallCheck.h"
 #include "PosixReturnCheck.h"
+#include "ReservedIdentifierCheck.h"
 #include "SignedCharMisuseCheck.h"
 #include "SizeofContainerCheck.h"
 #include "SizeofExpressionCheck.h"
@@ -120,6 +121,8 @@ class BugproneModule : public ClangTidyModule {
         "bugprone-parent-virtual-call");
     CheckFactories.registerCheck<PosixReturnCheck>(
         "bugprone-posix-return");
+    CheckFactories.registerCheck<ReservedIdentifierCheck>(
+        "bugprone-reserved-identifier");
     CheckFactories.registerCheck<SignedCharMisuseCheck>(
         "bugprone-signed-char-misuse");
     CheckFactories.registerCheck<SizeofContainerCheck>(

clang-tools-extra/clang-tidy/bugprone/CMakeLists.txt

@@ -28,6 +28,7 @@ add_clang_library(clangTidyBugproneModule
   NotNullTerminatedResultCheck.cpp
   ParentVirtualCallCheck.cpp
   PosixReturnCheck.cpp
+  ReservedIdentifierCheck.cpp
   SignedCharMisuseCheck.cpp
   SizeofContainerCheck.cpp
   SizeofExpressionCheck.cpp

clang-tools-extra/clang-tidy/bugprone/ReservedIdentifierCheck.cpp

@@ -0,0 +1,179 @@
+//===--- ReservedIdentifierCheck.cpp - clang-tidy -------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "ReservedIdentifierCheck.h"
+#include "../utils/Matchers.h"
+#include "../utils/OptionsUtils.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include <algorithm>
+#include <cctype>
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace bugprone {
+
+static const char DoubleUnderscoreTag[] = "du";
+static const char UnderscoreCapitalTag[] = "uc";
+static const char GlobalUnderscoreTag[] = "global-under";
+static const char NonReservedTag[] = "non-reserved";
+
+static const char Message[] =
+    "declaration uses identifier '%0', which is %select{a reserved "
+    "identifier|not a reserved identifier|reserved in the global namespace}1";
+
+static int getMessageSelectIndex(StringRef Tag) {
+  if (Tag == NonReservedTag)
+    return 1;
+  if (Tag == GlobalUnderscoreTag)
+    return 2;
+  return 0;
+}
+
+ReservedIdentifierCheck::ReservedIdentifierCheck(StringRef Name,
+                                                 ClangTidyContext *Context)
+    : RenamerClangTidyCheck(Name, Context),
+      Invert(Options.get("Invert", false)),
+      AllowedIdentifiers(utils::options::parseStringList(
+          Options.get("AllowedIdentifiers", ""))) {}
+
+void ReservedIdentifierCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "Invert", Invert);
+  Options.store(Opts, "AllowedIdentifiers",
+                utils::options::serializeStringList(AllowedIdentifiers));
+}
+
+static std::string collapseConsecutive(StringRef Str, char C) {
+  std::string Result;
+  std::unique_copy(Str.begin(), Str.end(), std::back_inserter(Result),
+                   [C](char A, char B) { return A == C && B == C; });
+  return Result;
+}
+
+static bool hasReservedDoubleUnderscore(StringRef Name,
+                                        const LangOptions &LangOpts) {
+  if (LangOpts.CPlusPlus)
+    return Name.find("__") != StringRef::npos;
+  return Name.startswith("__");
+}
+
+static Optional<std::string>
+getDoubleUnderscoreFixup(StringRef Name, const LangOptions &LangOpts) {
+  if (hasReservedDoubleUnderscore(Name, LangOpts))
+    return collapseConsecutive(Name, '_');
+  return None;
+}
+
+static bool startsWithUnderscoreCapital(StringRef Name) {
+  return Name.size() >= 2 && Name[0] == '_' && std::isupper(Name[1]);
+}
+
+static Optional<std::string> getUnderscoreCapitalFixup(StringRef Name) {
+  if (startsWithUnderscoreCapital(Name))
+    return std::string(Name.drop_front(1));
+  return None;
+}
+
+static bool startsWithUnderscoreInGlobalNamespace(StringRef Name,
+                                                  bool IsInGlobalNamespace) {
+  return IsInGlobalNamespace && Name.size() >= 1 && Name[0] == '_';
+}
+
+static Optional<std::string>
+getUnderscoreGlobalNamespaceFixup(StringRef Name, bool IsInGlobalNamespace) {
+  if (startsWithUnderscoreInGlobalNamespace(Name, IsInGlobalNamespace))
+    return std::string(Name.drop_front(1));
+  return None;
+}
+
+static std::string getNonReservedFixup(std::string Name) {
+  assert(!Name.empty());
+  if (Name[0] == '_' || std::isupper(Name[0]))
+    Name.insert(Name.begin(), '_');
+  else
+    Name.insert(Name.begin(), 2, '_');
+  return Name;
+}
+
+static Optional<RenamerClangTidyCheck::FailureInfo>
+getFailureInfoImpl(StringRef Name, bool IsInGlobalNamespace,
+                   const LangOptions &LangOpts, bool Invert,
+                   ArrayRef<std::string> AllowedIdentifiers) {
+  assert(!Name.empty());
+  if (llvm::is_contained(AllowedIdentifiers, Name))
+    return None;
+
+  // TODO: Check for names identical to language keywords, and other names
+  // specifically reserved by language standards, e.g. C++ 'zombie names' and C
+  // future library directions
+
+  using FailureInfo = RenamerClangTidyCheck::FailureInfo;
+  if (!Invert) {
+    Optional<FailureInfo> Info;
+    auto AppendFailure = [&](StringRef Kind, std::string &&Fixup) {
+      if (!Info) {
+        Info = FailureInfo{Kind, std::move(Fixup)};
+      } else {
+        Info->KindName += Kind;
+        Info->Fixup = std::move(Fixup);
+      }
+    };
+    auto InProgressFixup = [&] {
+      return Info
+          .map([](const FailureInfo &Info) { return StringRef(Info.Fixup); })
+          .getValueOr(Name);
+    };
+    if (auto Fixup = getDoubleUnderscoreFixup(InProgressFixup(), LangOpts))
+      AppendFailure(DoubleUnderscoreTag, std::move(*Fixup));
+    if (auto Fixup = getUnderscoreCapitalFixup(InProgressFixup()))
+      AppendFailure(UnderscoreCapitalTag, std::move(*Fixup));
+    if (auto Fixup = getUnderscoreGlobalNamespaceFixup(InProgressFixup(),
+                                                       IsInGlobalNamespace))
+      AppendFailure(GlobalUnderscoreTag, std::move(*Fixup));
+
+    return Info;
+  }
+  if (!(hasReservedDoubleUnderscore(Name, LangOpts) ||
+        startsWithUnderscoreCapital(Name) ||
+        startsWithUnderscoreInGlobalNamespace(Name, IsInGlobalNamespace)))
+    return FailureInfo{NonReservedTag, getNonReservedFixup(Name)};
+  return None;
+}
+
+Optional<RenamerClangTidyCheck::FailureInfo>
+ReservedIdentifierCheck::GetDeclFailureInfo(const NamedDecl *Decl,
+                                            const SourceManager &) const {
+  assert(Decl && Decl->getIdentifier() && !Decl->getName().empty() &&
+         !Decl->isImplicit() &&
+         "Decl must be an explicit identifier with a name.");
+  return getFailureInfoImpl(Decl->getName(),
+                            isa<TranslationUnitDecl>(Decl->getDeclContext()),
+                            getLangOpts(), Invert, AllowedIdentifiers);
+}
+
+Optional<RenamerClangTidyCheck::FailureInfo>
+ReservedIdentifierCheck::GetMacroFailureInfo(const Token &MacroNameTok,
+                                             const SourceManager &) const {
+  return getFailureInfoImpl(MacroNameTok.getIdentifierInfo()->getName(), true,
+                            getLangOpts(), Invert, AllowedIdentifiers);
+}
+
+RenamerClangTidyCheck::DiagInfo
+ReservedIdentifierCheck::GetDiagInfo(const NamingCheckId &ID,
+                                     const NamingCheckFailure &Failure) const {
+  return DiagInfo{Message, [&](DiagnosticBuilder &diag) {
+                    diag << ID.second
+                         << getMessageSelectIndex(Failure.Info.KindName);
+                  }};
+};
+
+} // namespace bugprone
+} // namespace tidy
+} // namespace clang

clang-tools-extra/clang-tidy/bugprone/ReservedIdentifierCheck.h

@@ -0,0 +1,57 @@
+//===--- ReservedIdentifierCheck.h - clang-tidy -----------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_RESERVEDIDENTIFIERCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_RESERVEDIDENTIFIERCHECK_H
+
+#include "../utils/RenamerClangTidyCheck.h"
+#include "llvm/ADT/Optional.h"
+#include <string>
+#include <vector>
+
+namespace clang {
+namespace tidy {
+namespace bugprone {
+
+/// Checks for usages of identifiers reserved for use by the implementation.
+///
+/// The C and C++ standards both reserve the following names for such use:
+/// * identifiers that begin with an underscore followed by an uppercase letter;
+/// * identifiers in the global namespace that begin with an underscore.
+///
+/// The C standard additionally reserves names beginning with a double
+/// underscore, while the C++ standard strengthens this to reserve names with a
+/// double underscore occurring anywhere.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-reserved-identifier.html
+class ReservedIdentifierCheck final : public RenamerClangTidyCheck {
+  const bool Invert;
+  const std::vector<std::string> AllowedIdentifiers;
+
+public:
+  ReservedIdentifierCheck(StringRef Name, ClangTidyContext *Context);
+
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+
+private:
+  llvm::Optional<FailureInfo>
+  GetDeclFailureInfo(const NamedDecl *Decl,
+                     const SourceManager &SM) const override;
+  llvm::Optional<FailureInfo>
+  GetMacroFailureInfo(const Token &MacroNameTok,
+                      const SourceManager &SM) const override;
+  DiagInfo GetDiagInfo(const NamingCheckId &ID,
+                       const NamingCheckFailure &Failure) const override;
+};
+
+} // namespace bugprone
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_RESERVEDIDENTIFIERCHECK_H