Revert of 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()) {
-        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));
-        }
+        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()) {
-      if (static_cast<RawPtr*>(ptr)->HasReferenceType())
-        return kReferencePtrToGCManaged;
-      else
-        return kRawPtrToGCManaged;
-    }
+    if (ptr->IsRawPtr())
+      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() ?
-                         (static_cast<RawPtr*>(Parent())->HasReferenceType() ?
-                             "reference" : "raw") :
+                     Parent()->IsRawPtr() ? "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 (!CheckFieldsVisitor::IsWarning(it->second))
+      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 (CheckFieldsVisitor::IsRawPtrError(it->second)) {
+      if (it->second == CheckFieldsVisitor::kRawPtrToGCManaged ||
+          it->second == CheckFieldsVisitor::kRawPtrToGCManagedWarning) {
         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");