Disallow heap objects containing unsafe on-heap iterators.

tools/clang/blink_gc_plugin/Edge.h

 // 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.
 
 #ifndef TOOLS_BLINK_GC_PLUGIN_EDGE_H_
 #define TOOLS_BLINK_GC_PLUGIN_EDGE_H_
 
 #include <cassert>
 #include <deque>
 #include <vector>
 
 #include "TracingStatus.h"
 
 class RecordInfo;
 
 class Edge;
 class Collection;
 class CrossThreadPersistent;
+class Iterator;
 class Member;
 class OwnPtr;
 class Persistent;
 class RawPtr;
 class RefPtr;
 class UniquePtr;
 class Value;
 class WeakMember;
 
 // Bare-bones visitor.
 class EdgeVisitor {
  public:
   virtual ~EdgeVisitor() {}
   virtual void VisitValue(Value*) {}
   virtual void VisitRawPtr(RawPtr*) {}
   virtual void VisitRefPtr(RefPtr*) {}
   virtual void VisitOwnPtr(OwnPtr*) {}
   virtual void VisitUniquePtr(UniquePtr*) {}
   virtual void VisitMember(Member*) {}
   virtual void VisitWeakMember(WeakMember*) {}
   virtual void VisitPersistent(Persistent*) {}
   virtual void VisitCrossThreadPersistent(CrossThreadPersistent*) {}
   virtual void VisitCollection(Collection*) {}
+  virtual void VisitIterator(Iterator*) {}
 };
 
 // Recursive edge visitor. The traversed path is accessible in context.
 class RecursiveEdgeVisitor : public EdgeVisitor {
  public:
   // Overrides that recursively walk the edges and record the path.
   void VisitValue(Value*) override;
   void VisitRawPtr(RawPtr*) override;
   void VisitRefPtr(RefPtr*) override;
   void VisitOwnPtr(OwnPtr*) override;
   void VisitUniquePtr(UniquePtr*) override;
   void VisitMember(Member*) override;
   void VisitWeakMember(WeakMember*) override;
   void VisitPersistent(Persistent*) override;
   void VisitCrossThreadPersistent(CrossThreadPersistent*) override;
   void VisitCollection(Collection*) override;
+  void VisitIterator(Iterator*) override;
 
  protected:
   typedef std::deque<Edge*> Context;
   Context& context() { return context_; }
   Edge* Parent() { return context_.empty() ? 0 : context_.front(); }
   void Enter(Edge* e) { return context_.push_front(e); }
   void Leave() { context_.pop_front(); }
 
   // Default callback to overwrite in visitor subclass.
   virtual void AtValue(Value*);
   virtual void AtRawPtr(RawPtr*);
   virtual void AtRefPtr(RefPtr*);
   virtual void AtOwnPtr(OwnPtr*);
   virtual void AtUniquePtr(UniquePtr*);
   virtual void AtMember(Member*);
   virtual void AtWeakMember(WeakMember*);
   virtual void AtPersistent(Persistent*);
   virtual void AtCrossThreadPersistent(CrossThreadPersistent*);
   virtual void AtCollection(Collection*);
+  virtual void AtIterator(Iterator*);
 
  private:
   Context context_;
 };
 
 // Base class for all edges.
 class Edge {
  public:
   enum NeedsTracingOption { kRecursive, kNonRecursive };
   enum LivenessKind { kWeak, kStrong, kRoot };
@@ skipping 187 matching lines @@
     return status;
   }
 
  private:
   RecordInfo* info_;
   Members members_;
   bool on_heap_;
   bool is_root_;
 };
 
+// An iterator edge is a direct edge to some iterator type.
+class Iterator : public Edge {
+ public:
+  Iterator(RecordInfo* info, bool on_heap, bool is_unsafe)
+      : info_(info), on_heap_(on_heap), is_unsafe_(is_unsafe) {}
+  ~Iterator() {}
+
+  void Accept(EdgeVisitor* visitor) { visitor->VisitIterator(this); }
+  LivenessKind Kind() override { return kStrong; }
+  bool NeedsFinalization() { return false; }
+  TracingStatus NeedsTracing(NeedsTracingOption) {
+    if (on_heap_)
+      return TracingStatus::Needed();
+    return TracingStatus::Unneeded();
+  }
+
+  RecordInfo* info() const { return info_; }
+
+  bool IsUnsafe() const { return is_unsafe_; }
+
+ private:
+  RecordInfo* info_;
+  bool on_heap_;
+  bool is_unsafe_;
+};
+
 #endif  // TOOLS_BLINK_GC_PLUGIN_EDGE_H_