Check that classes with non-trivial destructors have finalization support.

tools/clang/blink_gc_plugin/RecordInfo.h

 // Copyright 2014 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.
 
 // This file provides a wrapper for CXXRecordDecl that accumulates GC related
 // information about a class. Accumulated information is memoized and the info
 // objects are stored in a RecordCache.
 
 #ifndef TOOLS_BLINK_GC_PLUGIN_RECORD_INFO_H_
 #define TOOLS_BLINK_GC_PLUGIN_RECORD_INFO_H_
@@ skipping 14 matching lines @@
   GraphPoint() : traced_(false) {}
   void MarkTraced() { traced_ = true; }
   bool IsProperlyTraced() { return traced_ || !NeedsTracing().IsNeeded(); }
   virtual const TracingStatus NeedsTracing() = 0;
  private:
   bool traced_;
 };
 
 class BasePoint : public GraphPoint {
  public:
-  BasePoint(RecordInfo* info, const TracingStatus& status)
-      : info_(info), status_(status) {}
-  RecordInfo* info() { return info_; }
+  BasePoint(const clang::CXXBaseSpecifier& spec,
+            RecordInfo* info,
+            const TracingStatus& status)
+      : spec_(spec), info_(info), status_(status) {}
   const TracingStatus NeedsTracing() { return status_; }
   // Needed to change the status of bases with a pure-virtual trace.
   void MarkUnneeded() { status_ = TracingStatus::Unneeded(); }
+  const clang::CXXBaseSpecifier& spec() { return spec_; }
+  RecordInfo* info() { return info_; }
  private:
+  const clang::CXXBaseSpecifier& spec_;
   RecordInfo* info_;
   TracingStatus status_;
 };
 
 class FieldPoint : public GraphPoint {
  public:
   FieldPoint(clang::FieldDecl* field, Edge* edge) : field_(field), edge_(edge) {
     assert(edge && "FieldPoint edge must be non-null");
   }
   const TracingStatus NeedsTracing() {
@@ skipping 23 matching lines @@
   Bases& GetBases();
   clang::CXXMethodDecl* GetTraceMethod();
   clang::CXXMethodDecl* GetTraceDispatchMethod();
 
   bool GetTemplateArgs(size_t count, TemplateArgs* output_args);
 
   bool IsHeapAllocatedCollection();
   bool IsGCDerived();
   bool IsGCAllocated();
   bool IsGCFinalized();
+  bool IsUnmixedGCMixin();
 
   bool IsStackAllocated();
   bool RequiresTraceMethod();
+  bool NeedsFinalization();
   TracingStatus NeedsTracing(Edge::NeedsTracingOption);
 
  private:
   RecordInfo(clang::CXXRecordDecl* record, RecordCache* cache);
 
   Fields* CollectFields();
   Bases* CollectBases();
   void DetermineTracingMethods();
   bool InheritsNonPureTrace();
 
@@ skipping 29 matching lines @@
   }
 
   RecordInfo* Lookup(const clang::CXXRecordDecl* record) {
     return Lookup(const_cast<clang::CXXRecordDecl*>(record));
   }
 
   RecordInfo* Lookup(clang::Decl* decl) {
     return Lookup(clang::dyn_cast<clang::CXXRecordDecl>(decl));
   }
 
+  RecordInfo* Lookup(const clang::Type* type) {
+    return Lookup(type->getAsCXXRecordDecl());
+  }
+
+  RecordInfo* Lookup(const clang::QualType& type) {
+    return Lookup(type.getTypePtr());
+  }
+
   ~RecordCache() {
     for (Cache::iterator it = cache_.begin(); it != cache_.end(); ++it) {
       if (!it->second.fields_)
         continue;
       for (RecordInfo::Fields::iterator fit = it->second.fields_->begin();
         fit != it->second.fields_->end();
         ++fit) {
         fit->second.deleteEdge();
       }
     }
   }
 
  private:
   typedef std::map<clang::CXXRecordDecl*, RecordInfo> Cache;
   Cache cache_;
 };
 
 #endif  // TOOLS_BLINK_GC_PLUGIN_RECORD_INFO_H_