Blink GC plugin: Gracefully handle cyclic part objects.

tools/clang/blink_gc_plugin/BlinkGCPlugin.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.
 
 // This clang plugin checks various invariants of the Blink garbage
 // collection infrastructure.
 //
 // Errors are described at:
 // http://www.chromium.org/developers/blink-gc-plugin-errors
 
@@ skipping 554 matching lines @@
 
   CXXMethodDecl* trace_;
   RecordInfo* info_;
 };
 
 // This visitor checks that the fields of a class and the fields of
 // its part objects don't define GC roots.
 class CheckGCRootsVisitor : public RecursiveEdgeVisitor {
  public:
   typedef std::vector<FieldPoint*> RootPath;
+  typedef std::set<RecordInfo*> VisitingSet;
   typedef std::vector<RootPath> Errors;
 
   CheckGCRootsVisitor() {}
 
   Errors& gc_roots() { return gc_roots_; }
 
   bool ContainsGCRoots(RecordInfo* info) {
     for (RecordInfo::Fields::iterator it = info->GetFields().begin();
          it != info->GetFields().end();
          ++it) {
       current_.push_back(&it->second);
       it->second.edge()->Accept(this);
       current_.pop_back();
     }
     return !gc_roots_.empty();
   }
 
   void VisitValue(Value* edge) override {
     // TODO: what should we do to check unions?
     if (edge->value()->record()->isUnion())
       return;
 
+    // Prevent infinite regress for cyclic part objects.
+    if (visiting_set_.find(edge->value()) != visiting_set_.end())
+      return;
+
+    visiting_set_.insert(edge->value());
     // If the value is a part object, then continue checking for roots.
     for (Context::iterator it = context().begin();
          it != context().end();
          ++it) {
       if (!(*it)->IsCollection())
         return;
     }
     ContainsGCRoots(edge->value());
+    visiting_set_.erase(edge->value());
   }
 
   void VisitPersistent(Persistent* edge) override {
     gc_roots_.push_back(current_);
   }
 
   void AtCollection(Collection* edge) override {
     if (edge->is_root())
       gc_roots_.push_back(current_);
   }
 
  protected:
   RootPath current_;
+  VisitingSet visiting_set_;
   Errors gc_roots_;
 };
 
 // This visitor checks that the fields of a class are "well formed".
 // - OwnPtr, RefPtr and RawPtr must not point to a GC derived types.
 // - Part objects must not be GC derived types.
 // - An on-heap class must never contain GC roots.
 // - Only stack-allocated types may point to stack-allocated types.
 class CheckFieldsVisitor : public RecursiveEdgeVisitor {
  public:
@@ skipping 1251 matching lines @@
 
  private:
   BlinkGCPluginOptions options_;
 };
 
 }  // namespace
 
 static FrontendPluginRegistry::Add<BlinkGCPluginAction> X(
     "blink-gc-plugin",
     "Check Blink GC invariants");