Blink GC plugin: disallow GC derived types as part-object fields.

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 50 matching lines @@
 
 const char kOwnPtrToGCManagedClassNote[] =
     "[blink-gc] OwnPtr field %0 to a GC managed class declared here:";
 
 const char kStackAllocatedFieldNote[] =
     "[blink-gc] Stack-allocated field %0 declared here:";
 
 const char kMemberInUnmanagedClassNote[] =
     "[blink-gc] Member field %0 in unmanaged class declared here:";
 
-const char kPartObjectContainsGCRoot[] =
+const char kPartObjectToGCDerivedClassNote[] =
+    "[blink-gc] Part-object field %0 to a GC derived class declared here:";
+
+const char kPartObjectContainsGCRootNote[] =
     "[blink-gc] Field %0 with embedded GC root in %1 declared here:";
 
-const char kFieldContainsGCRoot[] =
+const char kFieldContainsGCRootNote[] =
     "[blink-gc] Field %0 defining a GC root declared here:";
 
 const char kOverriddenNonVirtualTrace[] =
     "[blink-gc] Class %0 overrides non-virtual trace of base class %1.";
 
 const char kOverriddenNonVirtualTraceNote[] =
     "[blink-gc] Non-virtual trace method declared here:";
 
 const char kMissingTraceDispatchMethod[] =
     "[blink-gc] Class %0 is missing manual trace dispatch.";
@@ skipping 353 matching lines @@
       gc_roots_.push_back(current_);
   }
 
  protected:
   RootPath current_;
   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:
-  typedef std::vector<std::pair<FieldPoint*, Edge*> > Errors;
+
+  enum Error {
+    kRawPtrToGCManaged,
+    kRefPtrToGCManaged,
+    kOwnPtrToGCManaged,
+    kMemberInUnmanaged,
+    kPtrFromHeapToStack,
+    kGCDerivedPartObject
+  };
+
+  typedef std::vector<std::pair<FieldPoint*, Error> > Errors;
 
   CheckFieldsVisitor(const BlinkGCPluginOptions& options)
       : options_(options), current_(0), stack_allocated_host_(false) {}
 
   Errors& invalid_fields() { return invalid_fields_; }
 
   bool ContainsInvalidFields(RecordInfo* info) {
     stack_allocated_host_ = info->IsStackAllocated();
     managed_host_ = stack_allocated_host_ ||
                     info->IsGCAllocated() ||
@@ skipping 12 matching lines @@
   void VisitMember(Member* edge) override {
     if (managed_host_)
       return;
     // A member is allowed to appear in the context of a root.
     for (Context::iterator it = context().begin();
          it != context().end();
          ++it) {
       if ((*it)->Kind() == Edge::kRoot)
         return;
     }
-    invalid_fields_.push_back(std::make_pair(current_, edge));
+    invalid_fields_.push_back(std::make_pair(current_, kMemberInUnmanaged));
   }
 
   void VisitValue(Value* edge) override {
     // TODO: what should we do to check unions?
     if (edge->value()->record()->isUnion())
       return;
 
     if (!stack_allocated_host_ && edge->value()->IsStackAllocated()) {
-      invalid_fields_.push_back(std::make_pair(current_, edge));
+      invalid_fields_.push_back(std::make_pair(current_, kPtrFromHeapToStack));
       return;
     }
 
+    if (!Parent() &&
+        edge->value()->IsGCDerived() &&
+        !edge->value()->IsGCMixin()) {
+      invalid_fields_.push_back(std::make_pair(current_, kGCDerivedPartObject));
+      return;
+    }
+
     if (!Parent() || !edge->value()->IsGCAllocated())
       return;
 
     // In transition mode, disallow  OwnPtr<T>, RawPtr<T> to GC allocated T's,
     // also disallow T* in stack-allocated types.
     if (options_.enable_oilpan) {
       if (Parent()->IsOwnPtr() ||
           Parent()->IsRawPtrClass() ||
           (stack_allocated_host_ && Parent()->IsRawPtr())) {
-        invalid_fields_.push_back(std::make_pair(current_, Parent()));
+        invalid_fields_.push_back(std::make_pair(
+            current_, InvalidSmartPtr(Parent())));
         return;
       }
 
       return;
     }
 
     if (Parent()->IsRawPtr() || Parent()->IsRefPtr() || Parent()->IsOwnPtr()) {
-      invalid_fields_.push_back(std::make_pair(current_, Parent()));
+      invalid_fields_.push_back(std::make_pair(
+          current_, InvalidSmartPtr(Parent())));
       return;
     }
   }
 
  private:
+  Error InvalidSmartPtr(Edge* ptr) {
+    if (ptr->IsRawPtr())
+      return kRawPtrToGCManaged;
+    if (ptr->IsRefPtr())
+      return kRefPtrToGCManaged;
+    if (ptr->IsOwnPtr())
+      return kOwnPtrToGCManaged;
+    assert(false && "Unknown smart pointer kind");
+  }
+
   const BlinkGCPluginOptions& options_;
   FieldPoint* current_;
   bool stack_allocated_host_;
   bool managed_host_;
   Errors invalid_fields_;
 };
 
 // Main class containing checks for various invariants of the Blink
 // garbage collection infrastructure.
 class BlinkGCPluginConsumer : public ASTConsumer {
@@ skipping 57 matching lines @@
     diag_raw_ptr_to_gc_managed_class_note_ = diagnostic_.getCustomDiagID(
         DiagnosticsEngine::Note, kRawPtrToGCManagedClassNote);
     diag_ref_ptr_to_gc_managed_class_note_ = diagnostic_.getCustomDiagID(
         DiagnosticsEngine::Note, kRefPtrToGCManagedClassNote);
     diag_own_ptr_to_gc_managed_class_note_ = diagnostic_.getCustomDiagID(
         DiagnosticsEngine::Note, kOwnPtrToGCManagedClassNote);
     diag_stack_allocated_field_note_ = diagnostic_.getCustomDiagID(
         DiagnosticsEngine::Note, kStackAllocatedFieldNote);
     diag_member_in_unmanaged_class_note_ = diagnostic_.getCustomDiagID(
         DiagnosticsEngine::Note, kMemberInUnmanagedClassNote);
+    diag_part_object_to_gc_derived_class_note_ = diagnostic_.getCustomDiagID(
+        DiagnosticsEngine::Note, kPartObjectToGCDerivedClassNote);
     diag_part_object_contains_gc_root_note_ = diagnostic_.getCustomDiagID(
-        DiagnosticsEngine::Note, kPartObjectContainsGCRoot);
+        DiagnosticsEngine::Note, kPartObjectContainsGCRootNote);
     diag_field_contains_gc_root_note_ = diagnostic_.getCustomDiagID(
-        DiagnosticsEngine::Note, kFieldContainsGCRoot);
+        DiagnosticsEngine::Note, kFieldContainsGCRootNote);
     diag_finalized_field_note_ = diagnostic_.getCustomDiagID(
         DiagnosticsEngine::Note, kFinalizedFieldNote);
     diag_user_declared_destructor_note_ = diagnostic_.getCustomDiagID(
         DiagnosticsEngine::Note, kUserDeclaredDestructorNote);
     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);
@@ skipping 98 matching lines @@
       ReportClassRequiresTraceMethod(info);
     }
 
     {
       CheckFieldsVisitor visitor(options_);
       if (visitor.ContainsInvalidFields(info))
         ReportClassContainsInvalidFields(info, &visitor.invalid_fields());
     }
 
     if (info->IsGCDerived()) {
-      CheckLeftMostDerived(info);
 
-      CheckDispatch(info);
-
-      if (CXXMethodDecl* newop = info->DeclaresNewOperator())
-        ReportClassOverridesNew(info, newop);
+      if (!info->IsGCMixin()) {
+        CheckLeftMostDerived(info);
+        CheckDispatch(info);
+        if (CXXMethodDecl* newop = info->DeclaresNewOperator())
+          ReportClassOverridesNew(info, newop);
+      }
 
       {
         CheckGCRootsVisitor visitor;
         if (visitor.ContainsGCRoots(info))
           ReportClassContainsGCRoots(info, &visitor.gc_roots());
       }
 
       if (info->NeedsFinalization())
         CheckFinalization(info);
     }
@@ skipping 406 matching lines @@
   void ReportClassContainsInvalidFields(RecordInfo* info,
                                         CheckFieldsVisitor::Errors* errors) {
     SourceLocation loc = info->record()->getLocStart();
     SourceManager& manager = instance_.getSourceManager();
     FullSourceLoc full_loc(loc, manager);
     diagnostic_.Report(full_loc, diag_class_contains_invalid_fields_)
         << info->record();
     for (CheckFieldsVisitor::Errors::iterator it = errors->begin();
          it != errors->end();
          ++it) {
-      if (it->second->IsRawPtr()) {
-        NoteField(it->first, diag_raw_ptr_to_gc_managed_class_note_);
-      } else if (it->second->IsRefPtr()) {
-        NoteField(it->first, diag_ref_ptr_to_gc_managed_class_note_);
-      } else if (it->second->IsOwnPtr()) {
-        NoteField(it->first, diag_own_ptr_to_gc_managed_class_note_);
-      } else if (it->second->IsMember()) {
-        NoteField(it->first, diag_member_in_unmanaged_class_note_);
-      } else if (it->second->IsValue()) {
-        NoteField(it->first, diag_stack_allocated_field_note_);
+      unsigned error;
+      if (it->second == CheckFieldsVisitor::kRawPtrToGCManaged) {
+        error = diag_raw_ptr_to_gc_managed_class_note_;
+      } else if (it->second == CheckFieldsVisitor::kRefPtrToGCManaged) {
+        error = diag_ref_ptr_to_gc_managed_class_note_;
+      } else if (it->second == CheckFieldsVisitor::kOwnPtrToGCManaged) {
+        error = diag_own_ptr_to_gc_managed_class_note_;
+      } else if (it->second == CheckFieldsVisitor::kMemberInUnmanaged) {
+        error = diag_member_in_unmanaged_class_note_;
+      } else if (it->second == CheckFieldsVisitor::kPtrFromHeapToStack) {
+        error = diag_stack_allocated_field_note_;
+      } else if (it->second == CheckFieldsVisitor::kGCDerivedPartObject) {
+        error = diag_part_object_to_gc_derived_class_note_;
+      } else {
+        assert(false && "Unknown field error");
       }
+      NoteField(it->first, error);
     }
   }
 
   void ReportClassContainsGCRoots(RecordInfo* info,
                                   CheckGCRootsVisitor::Errors* errors) {
     SourceLocation loc = info->record()->getLocStart();
     SourceManager& manager = instance_.getSourceManager();
     FullSourceLoc full_loc(loc, manager);
     for (CheckGCRootsVisitor::Errors::iterator it = errors->begin();
          it != errors->end();
@@ skipping 203 matching lines @@
   unsigned diag_class_overrides_new_;
   unsigned diag_class_declares_pure_virtual_trace_;
 
   unsigned diag_base_requires_tracing_note_;
   unsigned diag_field_requires_tracing_note_;
   unsigned diag_raw_ptr_to_gc_managed_class_note_;
   unsigned diag_ref_ptr_to_gc_managed_class_note_;
   unsigned diag_own_ptr_to_gc_managed_class_note_;
   unsigned diag_stack_allocated_field_note_;
   unsigned diag_member_in_unmanaged_class_note_;
+  unsigned diag_part_object_to_gc_derived_class_note_;
   unsigned diag_part_object_contains_gc_root_note_;
   unsigned diag_field_contains_gc_root_note_;
   unsigned diag_finalized_field_note_;
   unsigned diag_user_declared_destructor_note_;
   unsigned diag_user_declared_finalizer_note_;
   unsigned diag_base_requires_finalization_note_;
   unsigned diag_field_requires_finalization_note_;
   unsigned diag_overridden_non_virtual_trace_note_;
   unsigned diag_manual_dispatch_method_note_;
 
@@ skipping 35 matching lines @@
 
  private:
   BlinkGCPluginOptions options_;
 };
 
 }  // namespace
 
 static FrontendPluginRegistry::Add<BlinkGCPluginAction> X(
     "blink-gc-plugin",
     "Check Blink GC invariants");