Check for public dtors on base::RefCounted types

tools/clang/plugins/ChromeClassTester.cpp

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // A general interface for filtering and only acting on classes in Chromium C++
 // code.
 
 #include "ChromeClassTester.h"
 
 #include <sys/param.h>
@@ skipping 128 matching lines @@
 
     // We ignore all classes that end with "Matcher" because they're probably
     // GMock artifacts.
     if (ends_with(base_name, "Matcher"))
         return;
 
     CheckChromeClass(record_location, record);
   }
 }
 
-void ChromeClassTester::emitWarning(SourceLocation loc, const char* raw_error) {
+void ChromeClassTester::emitWarning(SourceLocation loc,
+                                    const char* raw_error) {
   FullSourceLoc full(loc, instance().getSourceManager());
   std::string err;
   err = "[chromium-style] ";
   err += raw_error;
   DiagnosticsEngine::Level level =
       diagnostic().getWarningsAsErrors() ?
       DiagnosticsEngine::Error :
       DiagnosticsEngine::Warning;
   unsigned id = diagnostic().getCustomDiagID(level, err);
   DiagnosticBuilder B = diagnostic().Report(full, id);
 }
 
-bool ChromeClassTester::InTestingNamespace(const Decl* record) {
-  return GetNamespace(record).find("testing") != std::string::npos;
-}
-
 bool ChromeClassTester::InBannedNamespace(const Decl* record) {
   std::string n = GetNamespace(record);
   if (n != "") {
     return std::find(banned_namespaces_.begin(), banned_namespaces_.end(), n)
         != banned_namespaces_.end();
   }
 
   return false;
 }
 
+bool ChromeClassTester::InImplementationFile(SourceLocation record_location) {
+  std::string filename;
+  if (!GetFilename(record_location, &filename)) {
+    return false;
+  }
+
+  if (ends_with(filename, ".cc") || ends_with(filename, ".cpp") ||
+      ends_with(filename, ".mm")) {
+    return true;
+  }
+
+  return false;
+}
+
 std::string ChromeClassTester::GetNamespace(const Decl* record) {
   return GetNamespaceImpl(record->getDeclContext(), "");
 }
 
 std::string ChromeClassTester::GetNamespaceImpl(const DeclContext* context,
-                                                std::string candidate) {
+                                                const std::string& candidate) {
   switch (context->getDeclKind()) {
     case Decl::TranslationUnit: {
       return candidate;
     }
     case Decl::Namespace: {
       const NamespaceDecl* decl = dyn_cast<NamespaceDecl>(context);
       std::string name_str;
       llvm::raw_string_ostream OS(name_str);
       if (decl->isAnonymousNamespace())
         OS << "<anonymous namespace>";
       else
         OS << *decl;
       return GetNamespaceImpl(context->getParent(),
                               OS.str());
     }
     default: {
       return GetNamespaceImpl(context->getParent(), candidate);
     }
   }
 }
 
 bool ChromeClassTester::InBannedDirectory(SourceLocation loc) {
-  const SourceManager &SM = instance_.getSourceManager();
-  SourceLocation spelling_location = SM.getSpellingLoc(loc);
-  PresumedLoc ploc = SM.getPresumedLoc(spelling_location);
-  std::string buffer_name;
-  if (ploc.isInvalid()) {
-    // If we're in an invalid location, we're looking at things that aren't
-    // actually stated in the source; treat this as a banned location instead
-    // of going through our full lookup process.
+  std::string filename;
+  if (!GetFilename(loc, &filename)) {
+    // If the filename cannot be determined, simply treat this as a banned
+    // location, instead of going through the full lookup process.
     return true;
-  } else {
-    std::string b = ploc.getFilename();
+  }
 
-    // We need to special case scratch space; which is where clang does its
-    // macro expansion. We explicitly want to allow people to do otherwise bad
-    // things through macros that were defined due to third party libraries.
-    if (b == "<scratch space>")
-      return true;
+  // We need to special case scratch space; which is where clang does its
+  // macro expansion. We explicitly want to allow people to do otherwise bad
+  // things through macros that were defined due to third party libraries.
+  if (filename == "<scratch space>")
+    return true;
 
-    // Don't complain about these things in implementation files.
-    if (ends_with(b, ".cc") || ends_with(b, ".cpp") || ends_with(b, ".mm")) {
-      return true;
-    }
+  // Don't complain about autogenerated protobuf files.
+  if (ends_with(filename, ".pb.h")) {
+    return true;
+  }
 
-    // Don't complain about autogenerated protobuf files.
-    if (ends_with(b, ".pb.h")) {
-      return true;
-    }
+  // We need to munge the paths so that they are relative to the repository
+  // srcroot. We first resolve the symlinktastic relative path and then
+  // remove our known srcroot from it if needed.
+  char resolvedPath[MAXPATHLEN];
+  if (realpath(filename.c_str(), resolvedPath)) {
+    filename = resolvedPath;
+  }
 
-    // We need to munge the paths so that they are relative to the repository
-    // srcroot. We first resolve the symlinktastic relative path and then
-    // remove our known srcroot from it if needed.
-    char resolvedPath[MAXPATHLEN];
-    if (realpath(b.c_str(), resolvedPath)) {
-      b = resolvedPath;
-    }
+  // On linux, chrome is often checked out to /usr/local/google. Due to the
+  // "usr" rule in banned_directories_, all diagnostics would be suppressed
+  // in that case. As a workaround, strip that prefix.
+  filename = lstrip(filename, "/usr/local/google");
 
-    // On linux, chrome is often checked out to /usr/local/google. Due to the
-    // "usr" rule in banned_directories_, all diagnostics would be suppressed
-    // in that case. As a workaround, strip that prefix.
-    b = lstrip(b, "/usr/local/google");
-
-    for (std::vector<std::string>::const_iterator it =
-             banned_directories_.begin();
-         it != banned_directories_.end(); ++it) {
-      // If we can find any of the banned path components in this path, then
-      // this file is rejected.
-      size_t index = b.find(*it);
-      if (index != std::string::npos) {
-        bool matches_full_dir_name = index == 0 || b[index - 1] == '/';
-        if ((*it)[0] == '/')
-          matches_full_dir_name = true;
-        if (matches_full_dir_name)
-          return true;
-      }
+  for (std::vector<std::string>::const_iterator it =
+           banned_directories_.begin();
+       it != banned_directories_.end(); ++it) {
+    // If we can find any of the banned path components in this path, then
+    // this file is rejected.
+    size_t index = filename.find(*it);
+    if (index != std::string::npos) {
+      bool matches_full_dir_name = index == 0 || filename[index - 1] == '/';
+      if ((*it)[0] == '/')
+        matches_full_dir_name = true;
+      if (matches_full_dir_name)
+        return true;
     }
   }
 
   return false;
 }
 
 bool ChromeClassTester::IsIgnoredType(const std::string& base_name) {
   return ignored_record_names_.find(base_name) != ignored_record_names_.end();
 }
+
+bool ChromeClassTester::GetFilename(SourceLocation loc,
+                                    std::string* filename) {
+  const SourceManager &SM = instance_.getSourceManager();
+  SourceLocation spelling_location = SM.getSpellingLoc(loc);
+  PresumedLoc ploc = SM.getPresumedLoc(spelling_location);
+  if (ploc.isInvalid()) {
+    // If we're in an invalid location, we're looking at things that aren't
+    // actually stated in the source.
+    return false;
+  }
+
+  *filename = ploc.getFilename();
+  return true;
+}