Check that classes with non-trivial destructors have finalization support.

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 23 matching lines @@
 
 const char kFieldRequiresTracingNote[] =
     "[blink-gc] Untraced field %0 declared here:";
 
 const char kClassContainsInvalidFields[] =
     "[blink-gc] Class %0 contains invalid fields.";
 
 const char kClassContainsGCRoot[] =
     "[blink-gc] Class %0 contains GC root in field %1.";
 
-const char kFinalizerInNonFinalizedClass[] =
-    "[blink-gc] Non-finalized class %0 has a user-declared finalizer %1.";
+const char kClassRequiresFinalization[] =
+    "[blink-gc] Class %0 requires finalization.";
 
 const char kFinalizerAccessesFinalizedField[] =
     "[blink-gc] Finalizer %0 accesses potentially finalized field %1.";
 
 const char kRawPtrToGCManagedClassNote[] =
     "[blink-gc] Raw pointer field %0 to a GC managed class declared here:";
 
 const char kRefPtrToGCManagedClassNote[] =
     "[blink-gc] RefPtr field %0 to a GC managed class declared here:";
 
 const char kOwnPtrToGCManagedClassNote[] =
     "[blink-gc] OwnPtr field %0 to a GC managed class declared here:";
 
 const char kPartObjectContainsGCRoot[] =
     "[blink-gc] Field %0 with embedded GC root in %1 declared here:";
 
 const char kFieldContainsGCRoot[] =
     "[blink-gc] Field %0 defining a GC root declared here:";
 
 const char kFinalizedFieldNote[] =
     "[blink-gc] Potentially finalized field %0 declared here:";
 
+const char kUserDeclaredDestructorNote[] =
+    "[blink-gc] User-declared destructor declared here:";
+
+const char kBaseRequiresFinalizationNote[] =
+    "[blink-gc] Base class %0 requiring finalization declared here:";
+
+const char kFieldRequiresFinalizationNote[] =
+    "[blink-gc] Field %0 requiring finalization declared here:";
+
 struct BlinkGCPluginOptions {
   BlinkGCPluginOptions() : enable_oilpan(false) {}
   bool enable_oilpan;
   std::set<std::string> ignored_classes;
   std::set<std::string> checked_namespaces;
   std::vector<std::string> ignored_directories;
 };
 
 typedef std::vector<CXXRecordDecl*> RecordVector;
 typedef std::vector<CXXMethodDecl*> MethodVector;
@@ skipping 324 matching lines @@
         diagnostic_.getCustomDiagID(getErrorLevel(), kClassRequiresTraceMethod);
     diag_base_requires_tracing_ =
         diagnostic_.getCustomDiagID(getErrorLevel(), kBaseRequiresTracing);
     diag_fields_require_tracing_ =
         diagnostic_.getCustomDiagID(getErrorLevel(), kFieldsRequireTracing);
     diag_class_contains_invalid_fields_ =
         diagnostic_.getCustomDiagID(getErrorLevel(),
                                     kClassContainsInvalidFields);
     diag_class_contains_gc_root_ =
         diagnostic_.getCustomDiagID(getErrorLevel(), kClassContainsGCRoot);
-    diag_finalizer_in_nonfinalized_class_ = diagnostic_.getCustomDiagID(
-        getErrorLevel(), kFinalizerInNonFinalizedClass);
+    diag_class_requires_finalization_ = diagnostic_.getCustomDiagID(
+        getErrorLevel(), kClassRequiresFinalization);
     diag_finalizer_accesses_finalized_field_ = diagnostic_.getCustomDiagID(
         getErrorLevel(), kFinalizerAccessesFinalizedField);
 
     // Register note messages.
     diag_field_requires_tracing_note_ = diagnostic_.getCustomDiagID(
         DiagnosticsEngine::Note, kFieldRequiresTracingNote);
     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_part_object_contains_gc_root_note_ = diagnostic_.getCustomDiagID(
         DiagnosticsEngine::Note, kPartObjectContainsGCRoot);
     diag_field_contains_gc_root_note_ = diagnostic_.getCustomDiagID(
         DiagnosticsEngine::Note, kFieldContainsGCRoot);
     diag_finalized_field_note_ = diagnostic_.getCustomDiagID(
         DiagnosticsEngine::Note, kFinalizedFieldNote);
+    diag_user_declared_destructor_note_ = diagnostic_.getCustomDiagID(
+        DiagnosticsEngine::Note, kUserDeclaredDestructorNote);
+    diag_base_requires_finalization_note_ = diagnostic_.getCustomDiagID(
+        DiagnosticsEngine::Note, kBaseRequiresFinalizationNote);
+    diag_field_requires_finalization_note_ = diagnostic_.getCustomDiagID(
+        DiagnosticsEngine::Note, kFieldRequiresFinalizationNote);
   }
 
   virtual void HandleTranslationUnit(ASTContext& context) {
     CollectVisitor visitor;
     visitor.TraverseDecl(context.getTranslationUnitDecl());
 
     for (RecordVector::iterator it = visitor.record_decls().begin();
          it != visitor.record_decls().end();
          ++it) {
       CheckRecord(cache_.Lookup(*it));
@@ skipping 41 matching lines @@
     if (info->RequiresTraceMethod() && !info->GetTraceMethod())
       ReportClassRequiresTraceMethod(info);
 
     {
       CheckFieldsVisitor visitor(options_);
       if (visitor.ContainsInvalidFields(info))
         ReportClassContainsInvalidFields(info, &visitor.invalid_fields());
     }
 
     if (info->IsGCDerived()) {
-      {
-        CheckGCRootsVisitor visitor;
-        if (visitor.ContainsGCRoots(info))
-          ReportClassContainsGCRoots(info, &visitor.gc_roots());
-      }
+      CheckGCRootsVisitor visitor;
+      if (visitor.ContainsGCRoots(info))
+        ReportClassContainsGCRoots(info, &visitor.gc_roots());
 
-      // TODO: check for non-user defined and non-trivial destructors too.
-      // TODO: support overridden finalize().
-      if (CXXDestructorDecl* dtor = info->record()->getDestructor()) {
-        if (dtor->isUserProvided() && !info->IsGCFinalized()) {
-          // Don't report if using transition types and the body is empty.
-          if (!options_.enable_oilpan) {
-            ReportFinalizerInNonFinalizedClass(info, dtor);
-          } else {
-            if (dtor->hasBody()) {
-              CompoundStmt* stmt = cast<CompoundStmt>(dtor->getBody());
-              if (stmt && !stmt->body_empty())
-                ReportFinalizerInNonFinalizedClass(info, dtor);
-            }
-          }
-        }
-
-        if (dtor->hasBody()) {
-          CheckFinalizerVisitor visitor(&cache_);
-          visitor.TraverseCXXMethodDecl(dtor);
-          if (!visitor.finalized_fields().empty()) {
-            ReportFinalizerAccessesFinalizedFields(dtor,
-                                                   &visitor.finalized_fields());
-          }
-        }
-      }
+      if (info->NeedsFinalization())
+        CheckFinalization(info);
     }
   }
 
+  void CheckFinalization(RecordInfo* info) {
+    // TODO: Should we collect destructors similar to trace methods?
+    // TODO: Check overridden finalize().
+    CXXDestructorDecl* dtor = info->record()->getDestructor();
+
+    // For finalized classes, check the finalization method if possible.
+    if (info->IsGCFinalized()) {
+      if (dtor && dtor->hasBody()) {
+        CheckFinalizerVisitor visitor(&cache_);
+        visitor.TraverseCXXMethodDecl(dtor);
+        if (!visitor.finalized_fields().empty()) {
+          ReportFinalizerAccessesFinalizedFields(
+              dtor, &visitor.finalized_fields());
+        }
+      }
+      return;
+    }
+
+    // Don't require finalization of a mixin that has not yet been "mixed in".
+    if (info->IsUnmixedGCMixin())
+      return;
+
+    // Report the finalization error, and proceed to print possible causes for
+    // the finalization requirement.
+    ReportClassRequiresFinalization(info);
+
+    if (dtor && dtor->isUserProvided())
+      NoteUserDeclaredDestructor(dtor);
+
+    for (RecordInfo::Bases::iterator it = info->GetBases().begin();
+         it != info->GetBases().end();
+         ++it) {
+      if (it->second.info()->NeedsFinalization())
+        NoteBaseRequiresFinalization(&it->second);
+    }
+
+    for (RecordInfo::Fields::iterator it = info->GetFields().begin();
+         it != info->GetFields().end();
+         ++it) {
+      if (it->second.edge()->NeedsFinalization())
+        NoteField(&it->second, diag_field_requires_finalization_note_);
+    }
+  }
+
   // This is the main entry for tracing method definitions.
   void CheckTracingMethod(CXXMethodDecl* method) {
     RecordInfo* parent = cache_.Lookup(method->getParent());
     if (IsIgnored(parent))
       return;
 
     // Check templated tracing methods by checking the template instantiations.
     // Specialized templates are handled as ordinary classes.
     if (ClassTemplateDecl* tmpl =
             parent->record()->getDescribedClassTemplate()) {
@@ skipping 181 matching lines @@
       diagnostic_.Report(full_loc, diag_class_contains_gc_root_)
           << info->record() << point->field();
       while (++path != it->end()) {
         NotePartObjectContainsGCRoot(point);
         point = *path;
       }
       NoteFieldContainsGCRoot(point);
     }
   }
 
-  void ReportFinalizerInNonFinalizedClass(RecordInfo* info,
-                                          CXXMethodDecl* dtor) {
-    SourceLocation loc = dtor->getLocStart();
-    SourceManager& manager = instance_.getSourceManager();
-    FullSourceLoc full_loc(loc, manager);
-    diagnostic_.Report(full_loc, diag_finalizer_in_nonfinalized_class_)
-        << info->record() << dtor;
-  }
-
   void ReportFinalizerAccessesFinalizedFields(
       CXXMethodDecl* dtor,
       CheckFinalizerVisitor::Errors* fields) {
     for (CheckFinalizerVisitor::Errors::iterator it = fields->begin();
          it != fields->end();
          ++it) {
       SourceLocation loc = it->first->getLocStart();
       SourceManager& manager = instance_.getSourceManager();
       FullSourceLoc full_loc(loc, manager);
       diagnostic_.Report(full_loc, diag_finalizer_accesses_finalized_field_)
           << dtor << it->second->field();
       NoteField(it->second, diag_finalized_field_note_);
     }
   }
 
+  void ReportClassRequiresFinalization(RecordInfo* info) {
+    SourceLocation loc = info->record()->getInnerLocStart();
+    SourceManager& manager = instance_.getSourceManager();
+    FullSourceLoc full_loc(loc, manager);
+    diagnostic_.Report(full_loc, diag_class_requires_finalization_)
+        << info->record();
+  }
+
   void NoteFieldRequiresTracing(RecordInfo* holder, FieldDecl* field) {
     NoteField(field, diag_field_requires_tracing_note_);
   }
 
   void NotePartObjectContainsGCRoot(FieldPoint* point) {
     FieldDecl* field = point->field();
     SourceLocation loc = field->getLocStart();
     SourceManager& manager = instance_.getSourceManager();
     FullSourceLoc full_loc(loc, manager);
     diagnostic_.Report(full_loc, diag_part_object_contains_gc_root_note_)
         << field << field->getParent();
   }
 
   void NoteFieldContainsGCRoot(FieldPoint* point) {
     NoteField(point, diag_field_contains_gc_root_note_);
   }
 
+  void NoteUserDeclaredDestructor(CXXMethodDecl* dtor) {
+    SourceLocation loc = dtor->getLocStart();
+    SourceManager& manager = instance_.getSourceManager();
+    FullSourceLoc full_loc(loc, manager);
+    diagnostic_.Report(full_loc, diag_user_declared_destructor_note_);
+  }
+
+  void NoteBaseRequiresFinalization(BasePoint* base) {
+    SourceLocation loc = base->spec().getLocStart();
+    SourceManager& manager = instance_.getSourceManager();
+    FullSourceLoc full_loc(loc, manager);
+    diagnostic_.Report(full_loc, diag_base_requires_finalization_note_)
+        << base->info()->record();
+  }
+
   void NoteField(FieldPoint* point, unsigned note) {
     NoteField(point->field(), note);
   }
 
   void NoteField(FieldDecl* field, unsigned note) {
     SourceLocation loc = field->getLocStart();
     SourceManager& manager = instance_.getSourceManager();
     FullSourceLoc full_loc(loc, manager);
     diagnostic_.Report(full_loc, note) << field;
   }
 
   unsigned diag_class_requires_trace_method_;
   unsigned diag_base_requires_tracing_;
   unsigned diag_fields_require_tracing_;
   unsigned diag_class_contains_invalid_fields_;
   unsigned diag_class_contains_gc_root_;
-  unsigned diag_finalizer_in_nonfinalized_class_;
+  unsigned diag_class_requires_finalization_;
   unsigned diag_finalizer_accesses_finalized_field_;
 
   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_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_base_requires_finalization_note_;
+  unsigned diag_field_requires_finalization_note_;
 
   CompilerInstance& instance_;
   DiagnosticsEngine& diagnostic_;
   BlinkGCPluginOptions options_;
   RecordCache cache_;
 };
 
 class BlinkGCPluginAction : public PluginASTAction {
  public:
   BlinkGCPluginAction() {}
@@ skipping 23 matching lines @@
 
  private:
   BlinkGCPluginOptions options_;
 };
 
 }  // namespace
 
 static FrontendPluginRegistry::Add<BlinkGCPluginAction> X(
     "blink-gc-plugin",
     "Check Blink GC invariants");