BlinkGCPlugin: require GC mixin instances to declare local trace().

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),
+      has_gc_mixin_methods_(kNotComputed),
+      is_declaring_local_trace_(kNotComputed),
       determined_trace_methods_(false),
       trace_method_(0),
       trace_dispatch_method_(0),
       finalize_dispatch_method_(0),
       is_gc_derived_(false) {}
 
 RecordInfo::~RecordInfo() {
   delete fields_;
   delete bases_;
 }
@@ skipping 270 matching lines @@
 CXXMethodDecl* RecordInfo::InheritsNonVirtualTrace() {
   if (CXXMethodDecl* trace = GetTraceMethod())
     return trace->isVirtual() ? 0 : trace;
   for (Bases::iterator it = GetBases().begin(); it != GetBases().end(); ++it) {
     if (CXXMethodDecl* trace = it->second.info()->InheritsNonVirtualTrace())
       return trace;
   }
   return 0;
 }
 
+bool RecordInfo::DeclaresGCMixinMethods() {
+  DetermineTracingMethods();
+  return has_gc_mixin_methods_;
+}
+
+bool RecordInfo::DeclaresLocalTraceMethod() {
+  if (is_declaring_local_trace_ != kNotComputed)
+    return is_declaring_local_trace_;
+  DetermineTracingMethods();
+  is_declaring_local_trace_ = trace_method_ ? kTrue : kFalse;
+  if (is_declaring_local_trace_) {
+    for (auto it = record_->method_begin();
+         it != record_->method_end(); ++it) {
+      if (*it == trace_method_) {
+        is_declaring_local_trace_ = kTrue;
+        break;
+      }
+    }
+  }
+  return is_declaring_local_trace_;
+}
+
+bool RecordInfo::IsGCMixinInstance() {
+  assert(IsGCDerived());
+  if (record_->isAbstract())
+    return false;
+
+  assert(!IsGCMixin());
+
+  // true iff the class derives from GCMixin and
+  // one or more other GC base classes.
+  bool seen_gc_mixin = false;
+  bool seen_gc_derived = false;
+  for (const auto& gc_base : gc_base_names_) {
+    if (Config::IsGCMixinBase(gc_base))
+      seen_gc_mixin = true;
+    else if (Config::IsGCBase(gc_base))
+      seen_gc_derived = true;
+  }
+  return seen_gc_derived && seen_gc_mixin;
+}
+
 // A (non-virtual) class is considered abstract in Blink if it has
 // no public constructors and no create methods.
 bool RecordInfo::IsConsideredAbstract() {
   for (CXXRecordDecl::ctor_iterator it = record_->ctor_begin();
        it != record_->ctor_end();
        ++it) {
     if (!it->isCopyOrMoveConstructor() && it->getAccess() == AS_public)
       return false;
   }
   for (CXXRecordDecl::method_iterator it = record_->method_begin();
@@ skipping 56 matching lines @@
 
 void RecordInfo::DetermineTracingMethods() {
   if (determined_trace_methods_)
     return;
   determined_trace_methods_ = true;
   if (Config::IsGCBase(name_))
     return;
   CXXMethodDecl* trace = 0;
   CXXMethodDecl* traceAfterDispatch = 0;
   bool isTraceAfterDispatch;
+  bool hasAdjustAndMark = false;
+  bool hasIsHeapObjectAlive = false;
   for (CXXRecordDecl::method_iterator it = record_->method_begin();
        it != record_->method_end();
        ++it) {
     if (Config::IsTraceMethod(*it, &isTraceAfterDispatch)) {
       if (isTraceAfterDispatch) {
         traceAfterDispatch = *it;
       } else {
         trace = *it;
       }
     } else if (it->getNameAsString() == kFinalizeName) {
       finalize_dispatch_method_ = *it;
+    } else if (it->getNameAsString() == kAdjustAndMarkName) {
+      hasAdjustAndMark = true;
+    } else if (it->getNameAsString() == kIsHeapObjectAliveName) {
+      hasIsHeapObjectAlive = true;
     }
   }
+  // Record if class defines the two GCMixin methods.
+  has_gc_mixin_methods_ =
+      hasAdjustAndMark && hasIsHeapObjectAlive ? kTrue : kFalse;
   if (traceAfterDispatch) {
     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;
   }
   if (trace_dispatch_method_ && finalize_dispatch_method_)
@@ skipping 161 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);
 }