Blink GC plugin: Add plugin flags for generating raw-pointer errors and unneeded-finalizer warnings.

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 32 matching lines @@
 
 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 kClassRequiresFinalization[] =
     "[blink-gc] Class %0 requires finalization.";
 
+const char kClassDoesNotRequireFinalization[] =
+    "[blink-gc] Class %0 may not require 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[] =
@@ skipping 68 matching lines @@
 
 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.";
 
 struct BlinkGCPluginOptions {
-  BlinkGCPluginOptions() : enable_oilpan(false), dump_graph(false) {}
+  BlinkGCPluginOptions()
+    : enable_oilpan(false)
+    , dump_graph(false)
+    , warn_raw_ptr(false)
+    , warn_unneeded_finalizer(false) {}
   bool enable_oilpan;
   bool dump_graph;
+  bool warn_raw_ptr;
+  bool warn_unneeded_finalizer;
   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;
 
 // Test if a template specialization is an instantiation.
 static bool IsTemplateInstantiation(CXXRecordDecl* record) {
@@ skipping 458 matching lines @@
 // 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:
 
   enum Error {
     kRawPtrToGCManaged,
+    kRawPtrToGCManagedWarning,
     kRefPtrToGCManaged,
     kOwnPtrToGCManaged,
     kMemberInUnmanaged,
     kPtrFromHeapToStack,
     kGCDerivedPartObject
   };
 
   typedef std::vector<std::pair<FieldPoint*, Error> > Errors;
 
   CheckFieldsVisitor(const BlinkGCPluginOptions& options)
@@ skipping 53 matching lines @@
     // 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_, InvalidSmartPtr(Parent())));
         return;
       }
-
+      if (options_.warn_raw_ptr && Parent()->IsRawPtr()) {
+        invalid_fields_.push_back(std::make_pair(
+            current_, kRawPtrToGCManagedWarning));
+      }
       return;
     }
 
     if (Parent()->IsRawPtr() || Parent()->IsRefPtr() || Parent()->IsOwnPtr()) {
       invalid_fields_.push_back(std::make_pair(
           current_, InvalidSmartPtr(Parent())));
       return;
     }
   }
 
@@ skipping 13 matching lines @@
     assert(false && "Unknown smart pointer kind");
   }
 
   const BlinkGCPluginOptions& options_;
   FieldPoint* current_;
   bool stack_allocated_host_;
   bool managed_host_;
   Errors invalid_fields_;
 };
 
+class EmptyStmtVisitor
+    : public RecursiveASTVisitor<EmptyStmtVisitor> {
+public:
+  static bool isEmpty(Stmt* stmt) {
+    EmptyStmtVisitor visitor;
+    visitor.TraverseStmt(stmt);
+    return visitor.empty_;
+  }
+
+  bool WalkUpFromCompoundStmt(CompoundStmt* stmt) {
+    empty_ = stmt->body_empty();
+    return false;
+  }
+  bool VisitStmt(Stmt*) {
+    empty_ = false;
+    return false;
+  }
+private:
+  EmptyStmtVisitor() : empty_(true) {}
+  bool empty_;
+};
+
 // Main class containing checks for various invariants of the Blink
 // garbage collection infrastructure.
 class BlinkGCPluginConsumer : public ASTConsumer {
  public:
   BlinkGCPluginConsumer(CompilerInstance& instance,
                         const BlinkGCPluginOptions& options)
       : instance_(instance),
         diagnostic_(instance.getDiagnostics()),
         options_(options),
         json_(0) {
 
     // Only check structures in the blink and WebKit namespaces.
     options_.checked_namespaces.insert("blink");
     options_.checked_namespaces.insert("WebKit");
 
     // Ignore GC implementation files.
     options_.ignored_directories.push_back("/heap/");
 
     // Register warning/error messages.
     diag_class_must_left_mostly_derive_gc_ = diagnostic_.getCustomDiagID(
         getErrorLevel(), kClassMustLeftMostlyDeriveGC);
     diag_class_requires_trace_method_ =
         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_invalid_fields_warning_ = diagnostic_.getCustomDiagID(
+        DiagnosticsEngine::Warning, kClassContainsInvalidFields);
     diag_class_contains_gc_root_ =
         diagnostic_.getCustomDiagID(getErrorLevel(), kClassContainsGCRoot);
     diag_class_requires_finalization_ = diagnostic_.getCustomDiagID(
         getErrorLevel(), kClassRequiresFinalization);
+    diag_class_does_not_require_finalization_ = diagnostic_.getCustomDiagID(
+        DiagnosticsEngine::Warning, kClassDoesNotRequireFinalization);
     diag_finalizer_accesses_finalized_field_ = diagnostic_.getCustomDiagID(
         getErrorLevel(), kFinalizerAccessesFinalizedField);
     diag_overridden_non_virtual_trace_ = diagnostic_.getCustomDiagID(
         getErrorLevel(), kOverriddenNonVirtualTrace);
     diag_missing_trace_dispatch_method_ = diagnostic_.getCustomDiagID(
         getErrorLevel(), kMissingTraceDispatchMethod);
     diag_missing_finalize_dispatch_method_ = diagnostic_.getCustomDiagID(
         getErrorLevel(), kMissingFinalizeDispatchMethod);
     diag_virtual_and_manual_dispatch_ =
         diagnostic_.getCustomDiagID(getErrorLevel(), kVirtualAndManualDispatch);
@@ skipping 162 matching lines @@
       }
 
       {
         CheckGCRootsVisitor visitor;
         if (visitor.ContainsGCRoots(info))
           ReportClassContainsGCRoots(info, &visitor.gc_roots());
       }
 
       if (info->NeedsFinalization())
         CheckFinalization(info);
+
+      if (options_.warn_unneeded_finalizer && info->IsGCFinalized())
+        CheckUnneededFinalization(info);
     }
 
     DumpClass(info);
   }
 
   CXXRecordDecl* GetDependentTemplatedDecl(const Type& type) {
     const TemplateSpecializationType* tmpl_type =
         type.getAs<TemplateSpecializationType>();
     if (!tmpl_type)
       return 0;
@@ skipping 204 matching lines @@
     }
 
     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_);
     }
   }
 
+  void CheckUnneededFinalization(RecordInfo* info) {
+    if (!HasNonEmptyFinalizer(info))
+      ReportClassDoesNotRequireFinalization(info);
+  }
+
+  bool HasNonEmptyFinalizer(RecordInfo* info) {
+    CXXDestructorDecl* dtor = info->record()->getDestructor();
+    if (dtor && dtor->isUserProvided()) {
+      if (!dtor->hasBody() || !EmptyStmtVisitor::isEmpty(dtor->getBody()))
+        return true;
+    }
+    for (RecordInfo::Bases::iterator it = info->GetBases().begin();
+         it != info->GetBases().end();
+         ++it) {
+      if (HasNonEmptyFinalizer(it->second.info()))
+        return true;
+    }
+    for (RecordInfo::Fields::iterator it = info->GetFields().begin();
+         it != info->GetFields().end();
+         ++it) {
+      if (it->second.edge()->NeedsFinalization())
+        return true;
+    }
+    return false;
+  }
+
   // 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 277 matching lines @@
       if (!it->second.IsProperlyTraced())
         NoteFieldRequiresTracing(info, it->first);
     }
   }
 
   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_)
+    bool only_warnings = options_.warn_raw_ptr;
+    for (CheckFieldsVisitor::Errors::iterator it = errors->begin();
+         only_warnings && it != errors->end();
+         ++it) {
+      if (it->second != CheckFieldsVisitor::kRawPtrToGCManagedWarning)
+        only_warnings = false;
+    }
+    diagnostic_.Report(full_loc, only_warnings ?
+                       diag_class_contains_invalid_fields_warning_ :
+                       diag_class_contains_invalid_fields_)
         << info->record();
     for (CheckFieldsVisitor::Errors::iterator it = errors->begin();
          it != errors->end();
          ++it) {
       unsigned error;
-      if (it->second == CheckFieldsVisitor::kRawPtrToGCManaged) {
+      if (it->second == CheckFieldsVisitor::kRawPtrToGCManaged ||
+          it->second == CheckFieldsVisitor::kRawPtrToGCManagedWarning) {
         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) {
@@ skipping 41 matching lines @@
   }
 
   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 ReportClassDoesNotRequireFinalization(RecordInfo* info) {
+    SourceLocation loc = info->record()->getInnerLocStart();
+    SourceManager& manager = instance_.getSourceManager();
+    FullSourceLoc full_loc(loc, manager);
+    diagnostic_.Report(full_loc, diag_class_does_not_require_finalization_)
+        << info->record();
+  }
+
   void ReportOverriddenNonVirtualTrace(RecordInfo* info,
                                        CXXMethodDecl* trace,
                                        CXXMethodDecl* overridden) {
     SourceLocation loc = trace->getLocStart();
     SourceManager& manager = instance_.getSourceManager();
     FullSourceLoc full_loc(loc, manager);
     diagnostic_.Report(full_loc, diag_overridden_non_virtual_trace_)
         << info->record() << overridden->getParent();
     NoteOverriddenNonVirtualTrace(overridden);
   }
@@ skipping 155 matching lines @@
     FullSourceLoc full_loc(loc, manager);
     diagnostic_.Report(full_loc, diag_overridden_non_virtual_trace_note_)
         << overridden;
   }
 
   unsigned diag_class_must_left_mostly_derive_gc_;
   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_invalid_fields_warning_;
   unsigned diag_class_contains_gc_root_;
   unsigned diag_class_requires_finalization_;
+  unsigned diag_class_does_not_require_finalization_;
   unsigned diag_finalizer_accesses_finalized_field_;
   unsigned diag_overridden_non_virtual_trace_;
   unsigned diag_missing_trace_dispatch_method_;
   unsigned diag_missing_finalize_dispatch_method_;
   unsigned diag_virtual_and_manual_dispatch_;
   unsigned diag_missing_trace_dispatch_;
   unsigned diag_missing_finalize_dispatch_;
   unsigned diag_derives_non_stack_allocated_;
   unsigned diag_class_overrides_new_;
   unsigned diag_class_declares_pure_virtual_trace_;
@@ skipping 38 matching lines @@
 
   virtual bool ParseArgs(const CompilerInstance& instance,
                          const std::vector<string>& args) {
     bool parsed = true;
 
     for (size_t i = 0; i < args.size() && parsed; ++i) {
       if (args[i] == "enable-oilpan") {
         options_.enable_oilpan = true;
       } else if (args[i] == "dump-graph") {
         options_.dump_graph = true;
+      } else if (args[i] == "warn-raw-ptr") {
+        options_.warn_raw_ptr = true;
+      } else if (args[i] == "warn-unneeded-finalizer") {
+        options_.warn_unneeded_finalizer = true;
       } else {
         parsed = false;
         llvm::errs() << "Unknown blink-gc-plugin argument: " << args[i] << "\n";
       }
     }
 
     return parsed;
   }
 
  private:
   BlinkGCPluginOptions options_;
 };
 
 }  // namespace
 
 static FrontendPluginRegistry::Add<BlinkGCPluginAction> X(
     "blink-gc-plugin",
     "Check Blink GC invariants");