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

tools/clang/blink_gc_plugin/RecordInfo.cpp

 // 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.
 
 #include "Config.h"
 #include "RecordInfo.h"
 
 #include "clang/AST/Attr.h"
 
 using namespace clang;
@@ skipping 156 matching lines @@
   }
   return false;
 }
 
 RecordInfo::Bases* RecordInfo::CollectBases() {
   // Compute the collection locally to avoid inconsistent states.
   Bases* bases = new Bases;
   for (CXXRecordDecl::base_class_iterator it = record_->bases_begin();
        it != record_->bases_end();
        ++it) {
-    if (CXXRecordDecl* base = it->getType()->getAsCXXRecordDecl()) {
+    const CXXBaseSpecifier& spec = *it;
+    if (CXXRecordDecl* base = spec.getType()->getAsCXXRecordDecl()) {
       RecordInfo* info = cache_->Lookup(base);
       TracingStatus status = info->InheritsNonPureTrace()
                                  ? TracingStatus::Needed()
                                  : TracingStatus::Unneeded();
-      bases->insert(std::make_pair(base, BasePoint(info, status)));
+      bases->insert(std::make_pair(base, BasePoint(spec, info, status)));
     }
   }
   return bases;
 }
 
 RecordInfo::Fields& RecordInfo::GetFields() {
   if (!fields_)
     fields_ = CollectFields();
   return *fields_;
 }
@@ skipping 41 matching lines @@
     trace_method_ = traceAfterDispatch;
     trace_dispatch_method_ = trace;
   } else {
     // TODO: Can we never have a dispatch method called trace without the same
     // class defining a traceAfterDispatch method?
     trace_method_ = trace;
     trace_dispatch_method_ = 0;
   }
 }
 
+// TODO: Add classes with a finalize() method that specialize FinalizerTrait.
+bool RecordInfo::NeedsFinalization() {
+  return record_->hasNonTrivialDestructor();
+}
+
 // A class needs tracing if:
 // - it is allocated on the managed heap,
 // - it defines a trace method (of the proper signature), or
 // - it contains fields that need tracing.
 TracingStatus RecordInfo::NeedsTracing(Edge::NeedsTracingOption option) {
   if (IsGCAllocated() || GetTraceMethod())
     return TracingStatus::Needed();
 
   if (option == Edge::kRecursive)
     GetFields();
@@ skipping 67 matching lines @@
     return 0;
   }
 
   if (Config::IsGCCollection(info->name()) ||
       Config::IsWTFCollection(info->name())) {
     bool is_root = Config::IsPersistentGCCollection(info->name());
     bool on_heap = is_root || info->IsHeapAllocatedCollection();
     size_t count = Config::CollectionDimension(info->name());
     if (!info->GetTemplateArgs(count, &args))
       return 0;
-    Collection* edge = new Collection(on_heap, is_root);
+    Collection* edge = new Collection(info, on_heap, is_root);
     for (TemplateArgs::iterator it = args.begin(); it != args.end(); ++it) {
       if (Edge* member = CreateEdge(*it)) {
         edge->members().push_back(member);
       } else {
         // We failed to create an edge so abort the entire edge construction.
         delete edge;  // Will delete the already allocated members.
         return 0;
       }
     }
     return edge;
   }
 
   return new Value(info);
 }