Merge from 'main' to 'sycl-web' (#1)

  CONFLICT (content): Merge conflict in clang/include/clang/Basic/DiagnosticDriverKinds.td

Author: speryt

clang-tools-extra/clang-tidy/abseil/AbseilMatcher.h

@@ -47,15 +47,11 @@ AST_POLYMORPHIC_MATCHER(
   if (PrefixPosition == StringRef::npos)
     return false;
   Path = Path.drop_front(PrefixPosition + AbslPrefix.size());
-  static const char *AbseilLibraries[] = {"algorithm", "base",
-                                          "container", "debugging",
-                                          "flags",     "hash",
-                                          "iterator",  "memory",
-                                          "meta",      "numeric",
-                                          "random",    "status",
-                                          "strings",   "synchronization",
-                                          "time",      "types",
-                                          "utility"};
+  static const char *AbseilLibraries[] = {
+      "algorithm", "base",     "container", "debugging", "flags",
+      "hash",      "iterator", "memory",    "meta",      "numeric",
+      "profiling", "random",   "status",    "strings",   "synchronization",
+      "time",      "types",    "utility"};
   return llvm::any_of(AbseilLibraries, [&](const char *Library) {
     return Path.startswith(Library);
   });

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

@@ -26,6 +26,7 @@ add_clang_library(clangTidyCppCoreGuidelinesModule
   ProTypeVarargCheck.cpp
   SlicingCheck.cpp
   SpecialMemberFunctionsCheck.cpp
+  VirtualClassDestructorCheck.cpp
 
   LINK_LIBS
   clangTidy

clang-tools-extra/clang-tidy/cppcoreguidelines/CppCoreGuidelinesTidyModule.cpp

@@ -35,6 +35,7 @@
 #include "ProTypeVarargCheck.h"
 #include "SlicingCheck.h"
 #include "SpecialMemberFunctionsCheck.h"
+#include "VirtualClassDestructorCheck.h"
 
 namespace clang {
 namespace tidy {
@@ -94,6 +95,8 @@ class CppCoreGuidelinesModule : public ClangTidyModule {
     CheckFactories.registerCheck<SlicingCheck>("cppcoreguidelines-slicing");
     CheckFactories.registerCheck<misc::UnconventionalAssignOperatorCheck>(
         "cppcoreguidelines-c-copy-assignment-signature");
+    CheckFactories.registerCheck<VirtualClassDestructorCheck>(
+        "cppcoreguidelines-virtual-class-destructor");
   }
 
   ClangTidyOptions getModuleOptions() override {

clang-tools-extra/clang-tidy/cppcoreguidelines/VirtualClassDestructorCheck.cpp

@@ -0,0 +1,200 @@
+//===--- VirtualClassDestructorCheck.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 "VirtualClassDestructorCheck.h"
+#include "../utils/LexerUtils.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Lex/Lexer.h"
+#include <string>
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace cppcoreguidelines {
+
+void VirtualClassDestructorCheck::registerMatchers(MatchFinder *Finder) {
+  ast_matchers::internal::Matcher<CXXRecordDecl> InheritsVirtualMethod =
+      hasAnyBase(hasType(cxxRecordDecl(has(cxxMethodDecl(isVirtual())))));
+
+  Finder->addMatcher(
+      cxxRecordDecl(
+          anyOf(has(cxxMethodDecl(isVirtual())), InheritsVirtualMethod),
+          unless(anyOf(
+              has(cxxDestructorDecl(isPublic(), isVirtual())),
+              has(cxxDestructorDecl(isProtected(), unless(isVirtual()))))))
+          .bind("ProblematicClassOrStruct"),
+      this);
+}
+
+static CharSourceRange
+getVirtualKeywordRange(const CXXDestructorDecl &Destructor,
+                       const SourceManager &SM, const LangOptions &LangOpts) {
+  SourceLocation VirtualBeginLoc = Destructor.getBeginLoc();
+  SourceLocation VirtualEndLoc = VirtualBeginLoc.getLocWithOffset(
+      Lexer::MeasureTokenLength(VirtualBeginLoc, SM, LangOpts));
+
+  /// Range ends with \c StartOfNextToken so that any whitespace after \c
+  /// virtual is included.
+  SourceLocation StartOfNextToken =
+      Lexer::findNextToken(VirtualEndLoc, SM, LangOpts)
+          .getValue()
+          .getLocation();
+
+  return CharSourceRange::getCharRange(VirtualBeginLoc, StartOfNextToken);
+}
+
+static const AccessSpecDecl *
+getPublicASDecl(const CXXRecordDecl &StructOrClass) {
+  for (DeclContext::specific_decl_iterator<AccessSpecDecl>
+           AS{StructOrClass.decls_begin()},
+       ASEnd{StructOrClass.decls_end()};
+       AS != ASEnd; ++AS) {
+    AccessSpecDecl *ASDecl = *AS;
+    if (ASDecl->getAccess() == AccessSpecifier::AS_public)
+      return ASDecl;
+  }
+
+  return nullptr;
+}
+
+static FixItHint
+generateUserDeclaredDestructor(const CXXRecordDecl &StructOrClass,
+                               const SourceManager &SourceManager) {
+  std::string DestructorString;
+  SourceLocation Loc;
+  bool AppendLineBreak = false;
+
+  const AccessSpecDecl *AccessSpecDecl = getPublicASDecl(StructOrClass);
+
+  if (!AccessSpecDecl) {
+    if (StructOrClass.isClass()) {
+      Loc = StructOrClass.getEndLoc();
+      DestructorString = "public:";
+      AppendLineBreak = true;
+    } else {
+      Loc = StructOrClass.getBraceRange().getBegin().getLocWithOffset(1);
+    }
+  } else {
+    Loc = AccessSpecDecl->getEndLoc().getLocWithOffset(1);
+  }
+
+  DestructorString = (llvm::Twine(DestructorString) + "\nvirtual ~" +
+                      StructOrClass.getName().str() + "() = default;" +
+                      (AppendLineBreak ? "\n" : ""))
+                         .str();
+
+  return FixItHint::CreateInsertion(Loc, DestructorString);
+}
+
+static std::string getSourceText(const CXXDestructorDecl &Destructor) {
+  std::string SourceText;
+  llvm::raw_string_ostream DestructorStream(SourceText);
+  Destructor.print(DestructorStream);
+  return SourceText;
+}
+
+static std::string eraseKeyword(std::string &DestructorString,
+                                const std::string &Keyword) {
+  size_t KeywordIndex = DestructorString.find(Keyword);
+  if (KeywordIndex != std::string::npos)
+    DestructorString.erase(KeywordIndex, Keyword.length());
+  return DestructorString;
+}
+
+static FixItHint changePrivateDestructorVisibilityTo(
+    const std::string &Visibility, const CXXDestructorDecl &Destructor,
+    const SourceManager &SM, const LangOptions &LangOpts) {
+  std::string DestructorString =
+      (llvm::Twine() + Visibility + ":\n" +
+       (Visibility == "public" && !Destructor.isVirtual() ? "virtual " : ""))
+          .str();
+
+  std::string OriginalDestructor = getSourceText(Destructor);
+  if (Visibility == "protected" && Destructor.isVirtualAsWritten())
+    OriginalDestructor = eraseKeyword(OriginalDestructor, "virtual ");
+
+  DestructorString =
+      (llvm::Twine(DestructorString) + OriginalDestructor +
+       (Destructor.isExplicitlyDefaulted() ? ";\n" : "") + "private:")
+          .str();
+
+  /// Semicolons ending an explicitly defaulted destructor have to be deleted.
+  /// Otherwise, the left-over semicolon trails the \c private: access
+  /// specifier.
+  SourceLocation EndLocation;
+  if (Destructor.isExplicitlyDefaulted())
+    EndLocation =
+        utils::lexer::findNextTerminator(Destructor.getEndLoc(), SM, LangOpts)
+            .getLocWithOffset(1);
+  else
+    EndLocation = Destructor.getEndLoc().getLocWithOffset(1);
+
+  auto OriginalDestructorRange =
+      CharSourceRange::getCharRange(Destructor.getBeginLoc(), EndLocation);
+  return FixItHint::CreateReplacement(OriginalDestructorRange,
+                                      DestructorString);
+}
+
+void VirtualClassDestructorCheck::check(
+    const MatchFinder::MatchResult &Result) {
+
+  const auto *MatchedClassOrStruct =
+      Result.Nodes.getNodeAs<CXXRecordDecl>("ProblematicClassOrStruct");
+
+  const CXXDestructorDecl *Destructor = MatchedClassOrStruct->getDestructor();
+  if (!Destructor)
+    return;
+
+  if (Destructor->getAccess() == AccessSpecifier::AS_private) {
+    diag(MatchedClassOrStruct->getLocation(),
+         "destructor of %0 is private and prevents using the type")
+        << MatchedClassOrStruct;
+    diag(MatchedClassOrStruct->getLocation(),
+         /*FixDescription=*/"make it public and virtual", DiagnosticIDs::Note)
+        << changePrivateDestructorVisibilityTo(
+               "public", *Destructor, *Result.SourceManager, getLangOpts());
+    diag(MatchedClassOrStruct->getLocation(),
+         /*FixDescription=*/"make it protected", DiagnosticIDs::Note)
+        << changePrivateDestructorVisibilityTo(
+               "protected", *Destructor, *Result.SourceManager, getLangOpts());
+
+    return;
+  }
+
+  // Implicit destructors are public and non-virtual for classes and structs.
+  bool ProtectedAndVirtual = false;
+  FixItHint Fix;
+
+  if (MatchedClassOrStruct->hasUserDeclaredDestructor()) {
+    if (Destructor->getAccess() == AccessSpecifier::AS_public) {
+      Fix = FixItHint::CreateInsertion(Destructor->getLocation(), "virtual ");
+    } else if (Destructor->getAccess() == AccessSpecifier::AS_protected) {
+      ProtectedAndVirtual = true;
+      Fix = FixItHint::CreateRemoval(getVirtualKeywordRange(
+          *Destructor, *Result.SourceManager, Result.Context->getLangOpts()));
+    }
+  } else {
+    Fix = generateUserDeclaredDestructor(*MatchedClassOrStruct,
+                                         *Result.SourceManager);
+  }
+
+  diag(MatchedClassOrStruct->getLocation(),
+       "destructor of %0 is %select{public and non-virtual|protected and "
+       "virtual}1")
+      << MatchedClassOrStruct << ProtectedAndVirtual;
+  diag(MatchedClassOrStruct->getLocation(),
+       "make it %select{public and virtual|protected and non-virtual}0",
+       DiagnosticIDs::Note)
+      << ProtectedAndVirtual << Fix;
+}
+
+} // namespace cppcoreguidelines
+} // namespace tidy
+} // namespace clang

clang-tools-extra/clang-tidy/cppcoreguidelines/VirtualClassDestructorCheck.h

@@ -0,0 +1,41 @@
+//===--- VirtualClassDestructorCheck.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_CPPCOREGUIDELINES_VIRTUALCLASSDESTRUCTORCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_VIRTUALCLASSDESTRUCTORCHECK_H
+
+#include "../ClangTidyCheck.h"
+#include <string>
+
+namespace clang {
+namespace tidy {
+namespace cppcoreguidelines {
+
+/// Finds base classes whose destructor is neither public and virtual
+/// nor protected and non-virtual.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-virtual-class-destructor.html
+class VirtualClassDestructorCheck : public ClangTidyCheck {
+public:
+  VirtualClassDestructorCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+
+  bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
+    return LangOpts.CPlusPlus;
+  }
+
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+};
+
+} // namespace cppcoreguidelines
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_VIRTUALCLASSDESTRUCTORCHECK_H

clang-tools-extra/docs/ReleaseNotes.rst

@@ -75,12 +75,21 @@ New checks
 - New :doc:`bugprone-suspicious-memory-comparison
   <clang-tidy/checks/bugprone-suspicious-memory-comparison>` check.
 
-  Finds potentially incorrect calls to ``memcmp()`` based on properties of the arguments.
+  Finds potentially incorrect calls to ``memcmp()`` based on properties of the
+  arguments.
+
+- New :doc:`cppcoreguidelines-virtual-class-destructor
+  <clang-tidy/checks/cppcoreguidelines-virtual-class-destructor>` check.
+
+  Finds virtual classes whose destructor is neither public and virtual nor
+  protected and non-virtual.
 
 - New :doc:`readability-identifier-length
   <clang-tidy/checks/readability-identifier-length>` check.
 
-  Reports identifiers whose names are too short. Currently checks local variables and function parameters only.
+  Reports identifiers whose names are too short. Currently checks local
+  variables and function parameters only.
+
 
 New check aliases
 ^^^^^^^^^^^^^^^^^

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines-virtual-class-destructor.rst

@@ -0,0 +1,57 @@
+.. title:: clang-tidy - cppcoreguidelines-virtual-class-destructor
+
+cppcoreguidelines-virtual-class-destructor
+===============================================
+
+Finds virtual classes whose destructor is neither public and virtual
+nor protected and non-virtual. A virtual class's destructor should be specified
+in one of these ways to prevent undefined behaviour.
+
+This check implements
+`C.35 <http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rc-dtor-virtual>`_
+from the CppCoreGuidelines.
+
+Note that this check will diagnose a class with a virtual method regardless of
+whether the class is used as a base class or not.
+
+Fixes are available for user-declared and implicit destructors that are either
+public and non-virtual or protected and virtual. No fixes are offered for
+private destructors. There, the decision whether to make them private and
+virtual or protected and non-virtual depends on the use case and is thus left
+to the user.
+
+Example
+-------
+
+For example, the following classes/structs get flagged by the check since they
+violate guideline **C.35**:
+
+.. code-block:: c++
+
+  struct Foo {        // NOK, protected destructor should not be virtual
+    virtual void f();
+  protected:
+    virtual ~Foo(){}
+  };
+
+  class Bar {         // NOK, public destructor should be virtual
+    virtual void f();
+  public:
+    ~Bar(){}
+  };
+
+This would be rewritten to look like this:
+
+.. code-block:: c++
+
+  struct Foo {        // OK, destructor is not virtual anymore
+    virtual void f();
+  protected:
+    ~Foo(){}
+  };
+
+  class Bar {         // OK, destructor is now virtual
+    virtual void f();
+  public:
+    virtual ~Bar(){}
+  };

clang-tools-extra/docs/clang-tidy/checks/list.rst

@@ -169,6 +169,7 @@ Clang-Tidy Checks
    `cppcoreguidelines-pro-type-vararg <cppcoreguidelines-pro-type-vararg.html>`_,
    `cppcoreguidelines-slicing <cppcoreguidelines-slicing.html>`_,
    `cppcoreguidelines-special-member-functions <cppcoreguidelines-special-member-functions.html>`_,
+   `cppcoreguidelines-virtual-class-destructor <cppcoreguidelines-virtual-class-destructor.html>`_, "Yes"
    `darwin-avoid-spinlock <darwin-avoid-spinlock.html>`_,
    `darwin-dispatch-once-nonstatic <darwin-dispatch-once-nonstatic.html>`_, "Yes"
    `fuchsia-default-arguments-calls <fuchsia-default-arguments-calls.html>`_,