Disallow heap objects containing unsafe on-heap iterators.

tools/clang/blink_gc_plugin/DiagnosticsReporter.cpp

 // Copyright 2016 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 "DiagnosticsReporter.h"
 
 using namespace clang;
 
 namespace {
 
@@ skipping 129 matching lines @@
     " is not permitted to declare a pure-virtual trace method.";
 
 const char kLeftMostBaseMustBePolymorphic[] =
     "[blink-gc] Left-most base class %0 of derived class %1"
     " must be polymorphic.";
 
 const char kBaseClassMustDeclareVirtualTrace[] =
     "[blink-gc] Left-most base class %0 of derived class %1"
     " must define a virtual trace method.";
 
+const char kIteratorToGCManagedCollectionNote[] =
+    "[blink-gc] Iterator field %0 to a GC managed collection declared here:";
+
 } // namespace
 
 DiagnosticBuilder DiagnosticsReporter::ReportDiagnostic(
     SourceLocation location,
     unsigned diag_id) {
   SourceManager& manager = instance_.getSourceManager();
   FullSourceLoc full_loc(location, manager);
   return diagnostic_.Report(full_loc, diag_id);
 }
 
@@ skipping 86 matching lines @@
   diag_user_declared_finalizer_note_ = diagnostic_.getCustomDiagID(
       DiagnosticsEngine::Note, kUserDeclaredFinalizerNote);
   diag_base_requires_finalization_note_ = diagnostic_.getCustomDiagID(
       DiagnosticsEngine::Note, kBaseRequiresFinalizationNote);
   diag_field_requires_finalization_note_ = diagnostic_.getCustomDiagID(
       DiagnosticsEngine::Note, kFieldRequiresFinalizationNote);
   diag_overridden_non_virtual_trace_note_ = diagnostic_.getCustomDiagID(
       DiagnosticsEngine::Note, kOverriddenNonVirtualTraceNote);
   diag_manual_dispatch_method_note_ = diagnostic_.getCustomDiagID(
       DiagnosticsEngine::Note, kManualDispatchMethodNote);
+  diag_iterator_to_gc_managed_collection_note_ = diagnostic_.getCustomDiagID(
+      DiagnosticsEngine::Note, kIteratorToGCManagedCollectionNote);
 }
 
 bool DiagnosticsReporter::hasErrorOccurred() const
 {
   return diagnostic_.hasErrorOccurred();
 }
 
 DiagnosticsEngine::Level DiagnosticsReporter::getErrorLevel() const {
   return diagnostic_.getWarningsAsErrors() ? DiagnosticsEngine::Error
                                            : DiagnosticsEngine::Warning;
@@ skipping 70 matching lines @@
     } else if (error.second == CheckFieldsVisitor::kUniquePtrToGCManaged) {
       note = diag_unique_ptr_to_gc_managed_class_note_;
     } else if (error.second == CheckFieldsVisitor::kMemberToGCUnmanaged) {
       note = diag_member_to_gc_unmanaged_class_note_;
     } else if (error.second == CheckFieldsVisitor::kMemberInUnmanaged) {
       note = diag_member_in_unmanaged_class_note_;
     } else if (error.second == CheckFieldsVisitor::kPtrFromHeapToStack) {
       note = diag_stack_allocated_field_note_;
     } else if (error.second == CheckFieldsVisitor::kGCDerivedPartObject) {
       note = diag_part_object_to_gc_derived_class_note_;
+    } else if (error.second == CheckFieldsVisitor::kIteratorToGCManaged) {
+      note = diag_iterator_to_gc_managed_collection_note_;
     } else {
       assert(false && "Unknown field error");
     }
     NoteField(error.first, note);
   }
 }
 
 void DiagnosticsReporter::ClassContainsGCRoots(
     RecordInfo* info,
     const CheckGCRootsVisitor::Errors& errors) {
@@ skipping 196 matching lines @@
 void DiagnosticsReporter::NoteField(FieldDecl* field, unsigned note) {
   ReportDiagnostic(field->getLocStart(), note) << field;
 }
 
 void DiagnosticsReporter::NoteOverriddenNonVirtualTrace(
     CXXMethodDecl* overridden) {
   ReportDiagnostic(overridden->getLocStart(),
                    diag_overridden_non_virtual_trace_note_)
       << overridden;
 }