Rolling forward clang, hiding some warnings

tools/clang/plugins/FindBadConstructsConsumer.cpp

 // Copyright (c) 2012 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.
 
 #include "FindBadConstructsConsumer.h"
 
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/AST/Attr.h"
 #include "clang/Lex/Lexer.h"
 #include "llvm/Support/raw_ostream.h"
@@ skipping 601 matching lines @@
       break;
     }
   }
 }
 
 // Check |record| for issues that are problematic for ref-counted types.
 // Note that |record| may not be a ref-counted type, but a base class for
 // a type that is.
 // If there are issues, update |loc| with the SourceLocation of the issue
 // and returns appropriately, or returns None if there are no issues.
+// static
 FindBadConstructsConsumer::RefcountIssue
 FindBadConstructsConsumer::CheckRecordForRefcountIssue(
     const CXXRecordDecl* record,
     SourceLocation& loc) {
   if (!record->hasUserDeclaredDestructor()) {
     loc = record->getLocation();
     return ImplicitDestructor;
   }
 
   if (CXXDestructorDecl* dtor = record->getDestructor()) {
     if (dtor->getAccess() == AS_public) {
       loc = dtor->getInnerLocStart();
       return PublicDestructor;
     }
   }
 
   return None;
 }
 
 // Returns true if |base| specifies one of the Chromium reference counted
 // classes (base::RefCounted / base::RefCountedThreadSafe).
-bool FindBadConstructsConsumer::IsRefCountedCallback(
+bool FindBadConstructsConsumer::IsRefCounted(
     const CXXBaseSpecifier* base,
-    CXXBasePath& path,
-    void* user_data) {
-  FindBadConstructsConsumer* self =
-      static_cast<FindBadConstructsConsumer*>(user_data);
-
+    CXXBasePath& path) {
+  FindBadConstructsConsumer* self = this;
   const TemplateSpecializationType* base_type =
       dyn_cast<TemplateSpecializationType>(
           UnwrapType(base->getType().getTypePtr()));
   if (!base_type) {
     // Base-most definition is not a template, so this cannot derive from
     // base::RefCounted. However, it may still be possible to use with a
     // scoped_refptr<> and support ref-counting, so this is not a perfect
     // guarantee of safety.
     return false;
   }
 
   TemplateName name = base_type->getTemplateName();
   if (TemplateDecl* decl = name.getAsTemplateDecl()) {
     std::string base_name = decl->getNameAsString();
 
     // Check for both base::RefCounted and base::RefCountedThreadSafe.
     if (base_name.compare(0, 10, "RefCounted") == 0 &&
         self->GetNamespace(decl) == "base") {
       return true;
     }
   }
 
   return false;
 }
 
 // Returns true if |base| specifies a class that has a public destructor,
 // either explicitly or implicitly.
+// static
 bool FindBadConstructsConsumer::HasPublicDtorCallback(
     const CXXBaseSpecifier* base,
     CXXBasePath& path,
     void* user_data) {
   // Only examine paths that have public inheritance, as they are the
   // only ones which will result in the destructor potentially being
   // exposed. This check is largely redundant, as Chromium code should be
   // exclusively using public inheritance.
   if (path.Access != AS_public)
     return false;
@@ skipping 37 matching lines @@
 // sticking it in a non-ref-counted container (like scoped_ptr<>).
 void FindBadConstructsConsumer::CheckRefCountedDtors(
     SourceLocation record_location,
     CXXRecordDecl* record) {
   // Skip anonymous structs.
   if (record->getIdentifier() == NULL)
     return;
 
   // Determine if the current type is even ref-counted.
   CXXBasePaths refcounted_path;
-  if (!record->lookupInBases(&FindBadConstructsConsumer::IsRefCountedCallback,
-                             this,
-                             refcounted_path)) {
+  if (!record->lookupInBases(
+          [this](const CXXBaseSpecifier* base, CXXBasePath& path) {
+            return IsRefCounted(base, path);
+          },
+          refcounted_path)) {
     return;  // Class does not derive from a ref-counted base class.
   }
 
   // Easy check: Check to see if the current type is problematic.
   SourceLocation loc;
   RefcountIssue issue = CheckRecordForRefcountIssue(record, loc);
   if (issue != None) {
     diagnostic().Report(loc, DiagnosticForIssue(issue));
     PrintInheritanceChain(refcounted_path.front());
     return;
@@ skipping 29 matching lines @@
   //   scoped_refptr<RefCountedInterface> some_class(
   //       new RefCountedInterface);
   //   // Calls SomeInterface::~SomeInterface(), which is unsafe.
   //   delete static_cast<SomeInterface*>(some_class.get());
   if (!options_.check_base_classes)
     return;
 
   // Find all public destructors. This will record the class hierarchy
   // that leads to the public destructor in |dtor_paths|.
   CXXBasePaths dtor_paths;
-  if (!record->lookupInBases(&FindBadConstructsConsumer::HasPublicDtorCallback,
-                             this,
-                             dtor_paths)) {
+  if (!record->lookupInBases(
+          [](const CXXBaseSpecifier* base, CXXBasePath& path) {
+            // TODO(thakis): Inline HasPublicDtorCallback() after clang roll.
+            return HasPublicDtorCallback(base, path, nullptr);
+          },
+          dtor_paths)) {
     return;
   }
 
   for (CXXBasePaths::const_paths_iterator it = dtor_paths.begin();
        it != dtor_paths.end();
        ++it) {
     // The record with the problem will always be the last record
     // in the path, since it is the record that stopped the search.
     const CXXRecordDecl* problem_record = dyn_cast<CXXRecordDecl>(
         it->back().Base->getType()->getAs<RecordType>()->getDecl());
@@ skipping 63 matching lines @@
     // one of those, it means there is at least one member after a factory.
     if (weak_ptr_factory_location.isValid() &&
         !param_is_weak_ptr_factory_to_self) {
       diagnostic().Report(weak_ptr_factory_location,
                           diag_weak_ptr_factory_order_);
     }
   }
 }
 
 }  // namespace chrome_checker