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 95 matching lines @@
        it != base_paths_->end();
        ++it) {
     const CXXBasePathElement& elem = (*it)[it->size() - 1];
     CXXRecordDecl* base = elem.Base->getType()->getAsCXXRecordDecl();
     if (Config::IsGCFinalizedBase(base->getName()))
       return true;
   }
   return false;
 }
 
+// A mixin has not yet been "mixed in" if its only GC base is the mixin base.
+bool RecordInfo::IsUnmixedGCMixin() {
+  if (!IsGCDerived() || base_paths_->begin() == base_paths_->end())
+    return false;
+  // Get the last element of the first path.
+  CXXBasePaths::paths_iterator it = base_paths_->begin();
+  const CXXBasePathElement& elem = (*it)[it->size() - 1];
+  CXXRecordDecl* base = elem.Base->getType()->getAsCXXRecordDecl();
+  // If it is not a mixin base we are done.
+  if (!Config::IsGCMixinBase(base->getName()))
+    return false;
+  // Otherwise, this is unmixed if there are no other paths to GC bases.
+  return ++it == base_paths_->end();
+}
+
 // Test if a record is allocated on the managed heap.
 bool RecordInfo::IsGCAllocated() {
   return IsGCDerived() || IsHeapAllocatedCollection();
 }
 
 static bool IsAnnotated(Decl* decl, const string& anno) {
   AnnotateAttr* attr = decl->getAttr<AnnotateAttr>();
   return attr && (attr->getAnnotation() == anno);
 }
 
@@ skipping 38 matching lines @@
   for (Bases::iterator it = GetBases().begin(); it != GetBases().end(); ++it) {
     if (it->second.info()->InheritsNonPureTrace())
       return true;
   }
   return false;
 }
 
 RecordInfo::Bases* RecordInfo::CollectBases() {
   // Compute the collection locally to avoid inconsistent states.
   Bases* bases = new Bases;
+  if (!record_->hasDefinition())
+    return bases;
   for (CXXRecordDecl::base_class_iterator it = record_->bases_begin();
        it != record_->bases_end();
        ++it) {
-    if (CXXRecordDecl* base = it->getType()->getAsCXXRecordDecl()) {
-      RecordInfo* info = cache_->Lookup(base);
-      TracingStatus status = info->InheritsNonPureTrace()
-                                 ? TracingStatus::Needed()
-                                 : TracingStatus::Unneeded();
-      bases->insert(std::make_pair(base, BasePoint(info, status)));
-    }
+    const CXXBaseSpecifier& spec = *it;
+    RecordInfo* info = cache_->Lookup(spec.getType());
+    if (!info)
+      continue;
+    CXXRecordDecl* base = info->record();
+    TracingStatus status = info->InheritsNonPureTrace()
+                               ? TracingStatus::Needed()
+                               : TracingStatus::Unneeded();
+    bases->insert(std::make_pair(base, BasePoint(spec, info, status)));
   }
   return bases;
 }
 
 RecordInfo::Fields& RecordInfo::GetFields() {
   if (!fields_)
     fields_ = CollectFields();
   return *fields_;
 }
 
 RecordInfo::Fields* RecordInfo::CollectFields() {
   // Compute the collection locally to avoid inconsistent states.
   Fields* fields = new Fields;
+  if (!record_->hasDefinition())
+    return fields;
   TracingStatus fields_status = TracingStatus::Unneeded();
   for (RecordDecl::field_iterator it = record_->field_begin();
        it != record_->field_end();
        ++it) {
     FieldDecl* field = *it;
     // Ignore fields annotated with the NO_TRACE_CHECKING macro.
     if (IsAnnotated(field, "blink_no_trace_checking"))
       continue;
     if (Edge* edge = CreateEdge(field->getType().getTypePtrOrNull())) {
       fields->insert(std::make_pair(field, FieldPoint(field, edge)));
@@ skipping 27 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 is derived from a class that needs tracing, or
 // - it contains fields that need tracing.
+// TODO: Defining NeedsTracing based on whether a class defines a trace method
+// (of the proper signature) over approximates too much. The use of transition
+// types causes some classes to have trace methods without them needing to be
+// traced.
 TracingStatus RecordInfo::NeedsTracing(Edge::NeedsTracingOption option) {
-  if (IsGCAllocated() || GetTraceMethod())
+  if (IsGCAllocated())
     return TracingStatus::Needed();
 
+  for (Bases::iterator it = GetBases().begin(); it != GetBases().end(); ++it) {
+    if (it->second.info()->NeedsTracing(option).IsNeeded())
+      return TracingStatus::Needed();
+  }
+
   if (option == Edge::kRecursive)
     GetFields();
 
   return fields_need_tracing_;
 }
 
 Edge* RecordInfo::CreateEdge(const Type* type) {
   if (!type) {
     return 0;
   }
 
   if (type->isPointerType()) {
     if (Edge* ptr = CreateEdge(type->getPointeeType().getTypePtrOrNull()))
       return new RawPtr(ptr);
     return 0;
   }
 
-  CXXRecordDecl* record = type->getAsCXXRecordDecl();
+  RecordInfo* info = cache_->Lookup(type);
 
   // If the type is neither a pointer or a C++ record we ignore it.
-  if (!record) {
+  if (!info) {
     return 0;
   }
 
-  RecordInfo* info = cache_->Lookup(record);
-
   TemplateArgs args;
 
   if (Config::IsRawPtr(info->name()) && info->GetTemplateArgs(1, &args)) {
     if (Edge* ptr = CreateEdge(args[0]))
       return new RawPtr(ptr);
     return 0;
   }
 
   if (Config::IsRefPtr(info->name()) && info->GetTemplateArgs(1, &args)) {
     if (Edge* ptr = CreateEdge(args[0]))
@@ skipping 33 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);
 }