Support ignorance of base class finalizers.

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"
 
 using namespace clang;
 using std::string;
 
 RecordInfo::RecordInfo(CXXRecordDecl* record, RecordCache* cache)
     : cache_(cache),
       record_(record),
       name_(record->getName()),
       fields_need_tracing_(TracingStatus::Unknown()),
       bases_(0),
       fields_(0),
       is_stack_allocated_(kNotComputed),
       is_non_newable_(kNotComputed),
       is_only_placement_newable_(kNotComputed),
+      does_need_finalization_(kNotComputed),
       determined_trace_methods_(false),
       trace_method_(0),
       trace_dispatch_method_(0),
       finalize_dispatch_method_(0),
       is_gc_derived_(false),
       base_paths_(0) {}
 
 RecordInfo::~RecordInfo() {
   delete fields_;
   delete bases_;
@@ skipping 362 matching lines @@
             it->second.info()->GetFinalizeDispatchMethod()) {
       assert(!finalize_dispatch_method_ &&
              "Multiple finalize dispatching methods");
       finalize_dispatch_method_ = dispatch;
     }
   }
 }
 
 // TODO: Add classes with a finalize() method that specialize FinalizerTrait.
 bool RecordInfo::NeedsFinalization() {
-  return record_->hasNonTrivialDestructor();
+  if (does_need_finalization_ == kNotComputed) {
+    // Rely on hasNonTrivialDestructor(), but if the only
+    // identifiable reason for it being true is the presence
+    // of a safely ignorable class as a direct base,
+    // or we're processing such an 'ignorable' class, then it does
+    // not need finalization.
+    does_need_finalization_ =
+        record_->hasNonTrivialDestructor() ? kTrue : kFalse;
+    if (!does_need_finalization_)
+      return does_need_finalization_;
+
+    // Processing a class with a safely-ignorable destructor.
+    NamespaceDecl* ns =
+        dyn_cast<NamespaceDecl>(record_->getDeclContext());
+    if (ns && Config::HasIgnorableDestructor(ns->getName(), name_)) {
+      does_need_finalization_ = kFalse;
+      return does_need_finalization_;
+    }
+
+    CXXDestructorDecl* dtor = record_->getDestructor();
+    if (dtor && dtor->isUserProvided())
+      return does_need_finalization_;
+    for (Fields::iterator it = GetFields().begin();
+         it != GetFields().end();
+         ++it) {
+      if (it->second.edge()->NeedsFinalization())
+        return does_need_finalization_;
+    }
+
+    for (Bases::iterator it = GetBases().begin();
+         it != GetBases().end();
+         ++it) {
+      if (it->second.info()->NeedsFinalization())
+        return does_need_finalization_;
+    }
+    // Destructor was non-trivial due to bases with destructors that
+    // can be safely ignored. Hence, no need for finalization.
+    does_need_finalization_ = kFalse;
+  }
+  return does_need_finalization_;
 }
 
 // A class needs tracing if:
 // - it is allocated on the managed heap,
 // - 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.
@@ skipping 92 matching lines @@
         edge->members().push_back(member);
       }
       // TODO: Handle the case where we fail to create an edge (eg, if the
       // argument is a primitive type or just not fully known yet).
     }
     return edge;
   }
 
   return new Value(info);
 }