Roll Clang 243039:245402

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 623 matching lines @@
       loc = dtor->getInnerLocStart();
       return PublicDestructor;
     }
   }
 
   return None;
 }
 
 // Returns true if |base| specifies one of the Chromium reference counted
 // classes (base::RefCounted / base::RefCountedThreadSafe).
-#if defined(LLVM_FORCE_HEAD_REVISION)
 bool FindBadConstructsConsumer::IsRefCounted(
     const CXXBaseSpecifier* base,
     CXXBasePath& path) {
   FindBadConstructsConsumer* self = this;
-#else
-// static
-bool FindBadConstructsConsumer::IsRefCountedCallback(
-    const CXXBaseSpecifier* base,
-    CXXBasePath& path,
-    void* user_data) {
-  FindBadConstructsConsumer* self =
-      static_cast<FindBadConstructsConsumer*>(user_data);
-#endif
   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;
   }
@@ skipping 65 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 defined(LLVM_FORCE_HEAD_REVISION)
   if (!record->lookupInBases(
           [this](const CXXBaseSpecifier* base, CXXBasePath& path) {
             return IsRefCounted(base, path);
           },
           refcounted_path)) {
-#else
-  if (!record->lookupInBases(&FindBadConstructsConsumer::IsRefCountedCallback,
-                             this,
-                             refcounted_path)) {
-#endif
     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 defined(LLVM_FORCE_HEAD_REVISION)
   if (!record->lookupInBases(
           [](const CXXBaseSpecifier* base, CXXBasePath& path) {
             // TODO(thakis): Inline HasPublicDtorCallback() after clang roll.
             return HasPublicDtorCallback(base, path, nullptr);
           },
           dtor_paths)) {
-#else
-  if (!record->lookupInBases(&FindBadConstructsConsumer::HasPublicDtorCallback,
-                             nullptr,
-                             dtor_paths)) {
-#endif
     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