blink_gc_plugin: detect singletons with embedded ScriptWrappables.

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[] =
+const char kIteratorToGCManagedCollection[] =
     "[blink-gc] Iterator field %0 to a GC managed collection declared here:";
 
-const char kTraceMethodOfStackAllocatedParentNote[] =
+const char kTraceMethodOfStackAllocatedParent[] =
     "[blink-gc] The stack allocated class %0 provides an unnecessary "
     "trace method:";
 
+const char kStaticSingletonContainsScriptWrappable[] =
+    "[blink-gc] The static singleton %0 contains one or more unsafe "
+    "ScriptWrappable references";
+
+const char kUnsafeScriptWrappableFieldNote[] =
+    "[blink-gc] Embedded unsafe ScriptWrappable-derived field with type '%1' "
+    "located at '%0'";
+
 } // 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);
 }
 
+DiagnosticBuilder DiagnosticsReporter::ReportDiagnostic(unsigned diag_id) {
+  return diagnostic_.Report(diag_id);
+}
+
 DiagnosticsReporter::DiagnosticsReporter(
     clang::CompilerInstance& instance)
     : instance_(instance),
       diagnostic_(instance.getDiagnostics())
 {
   // Register warning/error messages.
   diag_class_must_left_mostly_derive_gc_ = diagnostic_.getCustomDiagID(
       getErrorLevel(), kClassMustLeftMostlyDeriveGC);
   diag_class_requires_trace_method_ =
       diagnostic_.getCustomDiagID(getErrorLevel(), kClassRequiresTraceMethod);
@@ skipping 30 matching lines @@
   diag_stack_allocated_derives_gc_ = diagnostic_.getCustomDiagID(
       getErrorLevel(), kStackAllocatedDerivesGarbageCollected);
   diag_class_overrides_new_ =
       diagnostic_.getCustomDiagID(getErrorLevel(), kClassOverridesNew);
   diag_class_declares_pure_virtual_trace_ = diagnostic_.getCustomDiagID(
       getErrorLevel(), kClassDeclaresPureVirtualTrace);
   diag_left_most_base_must_be_polymorphic_ = diagnostic_.getCustomDiagID(
       getErrorLevel(), kLeftMostBaseMustBePolymorphic);
   diag_base_class_must_declare_virtual_trace_ = diagnostic_.getCustomDiagID(
       getErrorLevel(), kBaseClassMustDeclareVirtualTrace);
-  diag_iterator_to_gc_managed_collection_note_ = diagnostic_.getCustomDiagID(
-      getErrorLevel(), kIteratorToGCManagedCollectionNote);
+  diag_iterator_to_gc_managed_collection_ = diagnostic_.getCustomDiagID(
+      getErrorLevel(), kIteratorToGCManagedCollection);
   diag_trace_method_of_stack_allocated_parent_ = diagnostic_.getCustomDiagID(
-      getErrorLevel(), kTraceMethodOfStackAllocatedParentNote);
+      getErrorLevel(), kTraceMethodOfStackAllocatedParent);
+  diag_static_singleton_with_scriptwrappable_ = diagnostic_.getCustomDiagID(
+      getErrorLevel(), kStaticSingletonContainsScriptWrappable);
 
   // Register note messages.
   diag_base_requires_tracing_note_ = diagnostic_.getCustomDiagID(
       DiagnosticsEngine::Note, kBaseRequiresTracingNote);
   diag_field_requires_tracing_note_ = diagnostic_.getCustomDiagID(
       DiagnosticsEngine::Note, kFieldRequiresTracingNote);
   diag_field_should_not_be_traced_note_ = diagnostic_.getCustomDiagID(
       DiagnosticsEngine::Note, kFieldShouldNotBeTracedNote);
   diag_raw_ptr_to_gc_managed_class_note_ = diagnostic_.getCustomDiagID(
       DiagnosticsEngine::Note, kRawPtrToGCManagedClassNote);
@@ skipping 26 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_unsafe_scriptwrappable_field_note_ = diagnostic_.getCustomDiagID(
+      DiagnosticsEngine::Note, kUnsafeScriptWrappableFieldNote);
 }
 
 bool DiagnosticsReporter::hasErrorOccurred() const
 {
   return diagnostic_.hasErrorOccurred();
 }
 
 DiagnosticsEngine::Level DiagnosticsReporter::getErrorLevel() const {
   return diagnostic_.getWarningsAsErrors() ? DiagnosticsEngine::Error
                                            : DiagnosticsEngine::Warning;
@@ skipping 71 matching lines @@
       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_;
+      note = diag_iterator_to_gc_managed_collection_;
     } else {
       assert(false && "Unknown field error");
     }
     NoteField(error.first, note);
   }
 }
 
 void DiagnosticsReporter::ClassContainsGCRoots(
     RecordInfo* info,
     const CheckGCRootsVisitor::Errors& errors) {
@@ skipping 137 matching lines @@
 }
 
 void DiagnosticsReporter::TraceMethodForStackAllocatedClass(
     RecordInfo* info,
     CXXMethodDecl* trace) {
   ReportDiagnostic(trace->getLocStart(),
                    diag_trace_method_of_stack_allocated_parent_)
       << info->record();
 }
 
+void DiagnosticsReporter::StaticSingletonContainsScriptWrappable(
+    VarDecl* decl) {
+  ReportDiagnostic(decl->getLocStart(),
+                   diag_static_singleton_with_scriptwrappable_)
+      << decl;
+}
+
 void DiagnosticsReporter::NoteManualDispatchMethod(CXXMethodDecl* dispatch) {
   ReportDiagnostic(dispatch->getLocStart(),
                    diag_manual_dispatch_method_note_)
       << dispatch;
 }
 
 void DiagnosticsReporter::NoteBaseRequiresTracing(BasePoint* base) {
   ReportDiagnostic(base->spec().getLocStart(),
                    diag_base_requires_tracing_note_)
       << base->info()->record();
@@ skipping 47 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;
 }
+
+void DiagnosticsReporter::NoteUnsafeScriptWrappableField(
+    VarDecl* decl,
+    const std::string& context,
+    const std::string& type_name) {
+  ReportDiagnostic(diag_unsafe_scriptwrappable_field_note_) << context
+                                                            << type_name;
+}