Roll Chrome into Mojo.

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 122 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 kClassMustDeclareGCMixinTraceMethod[] =
+    "[blink-gc] Class %0 which inherits from GarbageCollectedMixin must"
+    " locally declare and override trace(Visitor*)";
+
 struct BlinkGCPluginOptions {
   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;
@@ skipping 687 matching lines @@
     diag_derives_non_stack_allocated_ =
         diagnostic_.getCustomDiagID(getErrorLevel(), kDerivesNonStackAllocated);
     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_class_must_declare_gc_mixin_trace_method_ =
+        diagnostic_.getCustomDiagID(getErrorLevel(),
+                                    kClassMustDeclareGCMixinTraceMethod);
 
     // Register note messages.
     diag_base_requires_tracing_note_ = diagnostic_.getCustomDiagID(
         DiagnosticsEngine::Note, kBaseRequiresTracingNote);
     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);
@@ skipping 138 matching lines @@
         ReportClassContainsInvalidFields(info, &visitor.invalid_fields());
     }
 
     if (info->IsGCDerived()) {
 
       if (!info->IsGCMixin()) {
         CheckLeftMostDerived(info);
         CheckDispatch(info);
         if (CXXMethodDecl* newop = info->DeclaresNewOperator())
           ReportClassOverridesNew(info, newop);
+        if (info->IsGCMixinInstance()) {
+          // Require that declared GCMixin implementations
+          // also provide a trace() override.
+          if (info->DeclaresGCMixinMethods()
+              && !info->DeclaresLocalTraceMethod())
+            ReportClassMustDeclareGCMixinTraceMethod(info);
+        }
       }
 
       {
         CheckGCRootsVisitor visitor;
         if (visitor.ContainsGCRoots(info))
           ReportClassContainsGCRoots(info, &visitor.gc_roots());
       }
 
       if (info->NeedsFinalization())
         CheckFinalization(info);
@@ skipping 75 matching lines @@
             return;
         }
         ReportBaseClassMustDeclareVirtualTrace(info, left_most);
         return;
       }
 
       // Check condition (2):
       if (DeclaresVirtualMethods(left_most))
         return;
       if (left_most_base) {
-        ++it; // Get the base next to the "safe polymorphic base"
+        // Get the base next to the "safe polymorphic base"
+        if (it != left_most->bases_end())
+          ++it;
         if (it != left_most->bases_end()) {
           if (CXXRecordDecl* next_base = it->getType()->getAsCXXRecordDecl()) {
             if (CXXRecordDecl* next_left_most = GetLeftMostBase(next_base)) {
               if (DeclaresVirtualMethods(next_left_most))
                 return;
               ReportLeftMostBaseMustBePolymorphic(info, next_left_most);
               return;
             }
           }
         }
@@ skipping 532 matching lines @@
   }
 
   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 ReportClassMustDeclareGCMixinTraceMethod(RecordInfo* info) {
+    SourceLocation loc = info->record()->getInnerLocStart();
+    SourceManager& manager = instance_.getSourceManager();
+    FullSourceLoc full_loc(loc, manager);
+    diagnostic_.Report(
+        full_loc, diag_class_must_declare_gc_mixin_trace_method_)
+        << 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 171 matching lines @@
   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_;
   unsigned diag_left_most_base_must_be_polymorphic_;
   unsigned diag_base_class_must_declare_virtual_trace_;
+  unsigned diag_class_must_declare_gc_mixin_trace_method_;
 
   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_;
@@ skipping 49 matching lines @@
 
  private:
   BlinkGCPluginOptions options_;
 };
 
 }  // namespace
 
 static FrontendPluginRegistry::Add<BlinkGCPluginAction> X(
     "blink-gc-plugin",
     "Check Blink GC invariants");