GC plugin: improve error reporting when tracing illegal fields.

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 {
 
 const char kClassMustLeftMostlyDeriveGC[] =
     "[blink-gc] Class %0 must derive its GC base in the left-most position.";
 
 const char kClassRequiresTraceMethod[] =
     "[blink-gc] Class %0 requires a trace method.";
 
 const char kBaseRequiresTracing[] =
     "[blink-gc] Base class %0 of derived class %1 requires tracing.";
 
 const char kBaseRequiresTracingNote[] =
     "[blink-gc] Untraced base class %0 declared here:";
 
 const char kFieldsRequireTracing[] =
     "[blink-gc] Class %0 has untraced fields that require tracing.";
 
+const char kFieldsImproperlyTraced[] =
+    "[blink-gc] Class %0 has untraced or not traceable fields.";
+
 const char kFieldRequiresTracingNote[] =
     "[blink-gc] Untraced field %0 declared here:";
 
+const char kFieldShouldNotBeTracedNote[] =
+    "[blink-gc] Untraceable field %0 declared here:";
+
 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[] =
@@ skipping 11 matching lines @@
 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 kUniquePtrToGCManagedClassNote[] =
+    "[blink-gc] std::unique_ptr 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[] =
     "[blink-gc] Member field %0 in unmanaged class declared here:";
 
 const char kPartObjectToGCDerivedClassNote[] =
@@ skipping 85 matching lines @@
 {
   // 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_fields_improperly_traced_ =
+      diagnostic_.getCustomDiagID(getErrorLevel(), kFieldsImproperlyTraced);
   diag_class_contains_invalid_fields_ = diagnostic_.getCustomDiagID(
       getErrorLevel(), 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);
@@ skipping 20 matching lines @@
   diag_left_most_base_must_be_polymorphic_ = diagnostic_.getCustomDiagID(
       getErrorLevel(), kLeftMostBaseMustBePolymorphic);
   diag_base_class_must_declare_virtual_trace_ = diagnostic_.getCustomDiagID(
       getErrorLevel(), kBaseClassMustDeclareVirtualTrace);
 
   // 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);
   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_unique_ptr_to_gc_managed_class_note_ = diagnostic_.getCustomDiagID(
+      DiagnosticsEngine::Note, kUniquePtrToGCManagedClassNote);
   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);
   diag_part_object_contains_gc_root_note_ = diagnostic_.getCustomDiagID(
       DiagnosticsEngine::Note, kPartObjectContainsGCRootNote);
@@ skipping 49 matching lines @@
 }
 
 void DiagnosticsReporter::BaseRequiresTracing(
     RecordInfo* derived,
     CXXMethodDecl* trace,
     CXXRecordDecl* base) {
   ReportDiagnostic(trace->getLocStart(), diag_base_requires_tracing_)
       << base << derived->record();
 }
 
-void DiagnosticsReporter::FieldsRequireTracing(
+void DiagnosticsReporter::FieldsImproperlyTraced(
     RecordInfo* info,
     CXXMethodDecl* trace) {
-  ReportDiagnostic(trace->getLocStart(), diag_fields_require_tracing_)
+  // Only mention untraceable in header diagnostic if they appear.
+  unsigned diag = diag_fields_require_tracing_;
+  for (auto& field : info->GetFields()) {
+    if (field.second.IsInproperlyTraced()) {
+      diag = diag_fields_improperly_traced_;
+      break;
+    }
+  }
+  ReportDiagnostic(trace->getLocStart(), diag)
       << info->record();
-  for (auto& field : info->GetFields())
+  for (auto& field : info->GetFields()) {
     if (!field.second.IsProperlyTraced())
       NoteFieldRequiresTracing(info, field.first);
+    if (field.second.IsInproperlyTraced())
+      NoteFieldShouldNotBeTraced(info, field.first);
+  }
 }
 
 void DiagnosticsReporter::ClassContainsInvalidFields(
     RecordInfo* info,
     const CheckFieldsVisitor::Errors& errors) {
 
   ReportDiagnostic(info->record()->getLocStart(),
                    diag_class_contains_invalid_fields_)
       << info->record();
 
   for (auto& error : errors) {
     unsigned note;
     if (error.second == CheckFieldsVisitor::kRawPtrToGCManaged) {
       note = diag_raw_ptr_to_gc_managed_class_note_;
     } else if (error.second == CheckFieldsVisitor::kRefPtrToGCManaged) {
       note = diag_ref_ptr_to_gc_managed_class_note_;
     } else if (error.second == CheckFieldsVisitor::kReferencePtrToGCManaged) {
       note = diag_reference_ptr_to_gc_managed_class_note_;
     } else if (error.second == CheckFieldsVisitor::kOwnPtrToGCManaged) {
       note = diag_own_ptr_to_gc_managed_class_note_;
+    } else if (error.second == CheckFieldsVisitor::kUniquePtrToGCManaged) {
+      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 {
       assert(false && "Unknown field error");
@@ skipping 155 matching lines @@
                    diag_base_requires_tracing_note_)
       << base->info()->record();
 }
 
 void DiagnosticsReporter::NoteFieldRequiresTracing(
     RecordInfo* holder,
     FieldDecl* field) {
   NoteField(field, diag_field_requires_tracing_note_);
 }
 
+void DiagnosticsReporter::NoteFieldShouldNotBeTraced(
+    RecordInfo* holder,
+    FieldDecl* field) {
+  NoteField(field, diag_field_should_not_be_traced_note_);
+}
+
 void DiagnosticsReporter::NotePartObjectContainsGCRoot(FieldPoint* point) {
   FieldDecl* field = point->field();
   ReportDiagnostic(field->getLocStart(),
                    diag_part_object_contains_gc_root_note_)
       << field << field->getParent();
 }
 
 void DiagnosticsReporter::NoteFieldContainsGCRoot(FieldPoint* point) {
   NoteField(point, diag_field_contains_gc_root_note_);
 }
@@ skipping 23 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;
 }