GC plugin: consider references equal to raw pointers.

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 kFinalizerAccessesEagerlyFinalizedField[] =
     "[blink-gc] Finalizer %0 accesses eagerly 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 kReferencePtrToGCManagedClassNote[] =
+    "[blink-gc] Reference pointer 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 kMemberToGCUnmanagedClassNote[] =
     "[blink-gc] Member field %0 to non-GC managed class declared here:";
 
 const char kStackAllocatedFieldNote[] =
     "[blink-gc] Stack-allocated field %0 declared here:";
 
 const char kMemberInUnmanagedClassNote[] =
@@ skipping 765 matching lines @@
 // - 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,
+    kReferencePtrToGCManaged,
+    kReferencePtrToGCManagedWarning,
     kOwnPtrToGCManaged,
     kMemberToGCUnmanaged,
     kMemberInUnmanaged,
     kPtrFromHeapToStack,
     kGCDerivedPartObject
   };
 
   typedef std::vector<std::pair<FieldPoint*, Error> > Errors;
 
   CheckFieldsVisitor(const BlinkGCPluginOptions& options)
@@ skipping 71 matching lines @@
     // 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));
+        if (static_cast<RawPtr*>(Parent())->HasReferenceType()) {
+          invalid_fields_.push_back(std::make_pair(
+              current_, kReferencePtrToGCManagedWarning));
+        } else {
+          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;
     }
   }
 
   void AtCollection(Collection* edge) override {
     if (edge->on_heap() && Parent() && Parent()->IsOwnPtr())
       invalid_fields_.push_back(std::make_pair(current_, kOwnPtrToGCManaged));
   }
 
+  static bool IsWarning(Error error) {
+    if (error == kRawPtrToGCManagedWarning)
+      return true;
+    if (error == kReferencePtrToGCManagedWarning)
+      return true;
+    return false;
+  }
+
+  static bool IsRawPtrError(Error error) {
+    return error == kRawPtrToGCManaged ||
+        error == kRawPtrToGCManagedWarning;
+  }
+
+  static bool IsReferencePtrError(Error error) {
+    return error == kReferencePtrToGCManaged ||
+        error == kReferencePtrToGCManagedWarning;
+  }
+
  private:
   Error InvalidSmartPtr(Edge* ptr) {
-    if (ptr->IsRawPtr())
-      return kRawPtrToGCManaged;
+    if (ptr->IsRawPtr()) {
+      if (static_cast<RawPtr*>(ptr)->HasReferenceType())
+        return kReferencePtrToGCManaged;
+      else
+        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_;
@@ skipping 91 matching lines @@
 
     // 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);
+    diag_reference_ptr_to_gc_managed_class_note_ = diagnostic_.getCustomDiagID(
+        DiagnosticsEngine::Note, kReferencePtrToGCManagedClassNote);
     diag_own_ptr_to_gc_managed_class_note_ = diagnostic_.getCustomDiagID(
         DiagnosticsEngine::Note, kOwnPtrToGCManagedClassNote);
     diag_member_to_gc_unmanaged_class_note_ = diagnostic_.getCustomDiagID(
         DiagnosticsEngine::Note, kMemberToGCUnmanagedClassNote);
     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);
@@ skipping 530 matching lines @@
                     const Edge::LivenessKind& kind,
                     const string& loc) {
         json_->OpenObject();
         json_->Write("src", src->record()->getQualifiedNameAsString());
         json_->Write("dst", dst->record()->getQualifiedNameAsString());
         json_->Write("lbl", lbl);
         json_->Write("kind", kind);
         json_->Write("loc", loc);
         json_->Write("ptr",
                      !Parent() ? "val" :
-                     Parent()->IsRawPtr() ? "raw" :
+                     Parent()->IsRawPtr() ?
+                         (static_cast<RawPtr*>(Parent())->HasReferenceType() ?
+                             "reference" : "raw") :
                      Parent()->IsRefPtr() ? "ref" :
                      Parent()->IsOwnPtr() ? "own" :
                      (Parent()->IsMember() ||
                       Parent()->IsWeakMember()) ? "mem" :
                      "val");
         json_->CloseObject();
       }
 
       void DumpField(RecordInfo* src, FieldPoint* point, const string& loc) {
         src_ = src;
@@ skipping 190 matching lines @@
 
   void ReportClassContainsInvalidFields(RecordInfo* info,
                                         CheckFieldsVisitor::Errors* errors) {
     SourceLocation loc = info->record()->getLocStart();
     SourceManager& manager = instance_.getSourceManager();
     FullSourceLoc full_loc(loc, manager);
     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)
+      if (!CheckFieldsVisitor::IsWarning(it->second))
         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 ||
-          it->second == CheckFieldsVisitor::kRawPtrToGCManagedWarning) {
+      if (CheckFieldsVisitor::IsRawPtrError(it->second)) {
         error = diag_raw_ptr_to_gc_managed_class_note_;
+      } else if (CheckFieldsVisitor::IsReferencePtrError(it->second)) {
+        error = diag_reference_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::kMemberToGCUnmanaged) {
         error = diag_member_to_gc_unmanaged_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_;
@@ skipping 264 matching lines @@
   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_reference_ptr_to_gc_managed_class_note_;
   unsigned diag_own_ptr_to_gc_managed_class_note_;
   unsigned diag_member_to_gc_unmanaged_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_eagerly_finalized_field_note_;
   unsigned diag_user_declared_destructor_note_;
@@ skipping 46 matching lines @@
 
  private:
   BlinkGCPluginOptions options_;
 };
 
 }  // namespace
 
 static FrontendPluginRegistry::Add<BlinkGCPluginAction> X(
     "blink-gc-plugin",
     "Check Blink GC invariants");