Update from https://crrev.com/333737

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
 
+#include <algorithm>
+
 #include "Config.h"
 #include "JsonWriter.h"
 #include "RecordInfo.h"
 
 #include "clang/AST/AST.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendPluginRegistry.h"
+#include "clang/Sema/Sema.h"
 
 using namespace clang;
 using std::string;
 
 namespace {
 
 const char kClassMustLeftMostlyDeriveGC[] =
     "[blink-gc] Class %0 must derive its GC base in the left-most position.";
 
 const char kClassRequiresTraceMethod[] =
@@ skipping 19 matching lines @@
 
 const char kClassRequiresFinalization[] =
     "[blink-gc] Class %0 requires finalization.";
 
 const char kClassDoesNotRequireFinalization[] =
     "[blink-gc] Class %0 may not require finalization.";
 
 const char kFinalizerAccessesFinalizedField[] =
     "[blink-gc] Finalizer %0 accesses potentially finalized field %1.";
 
+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 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[] =
     "[blink-gc] Member field %0 in unmanaged class declared here:";
 
 const char kPartObjectToGCDerivedClassNote[] =
     "[blink-gc] Part-object field %0 to a GC derived class declared here:";
 
 const char kPartObjectContainsGCRootNote[] =
@@ skipping 20 matching lines @@
 
 const char kMissingTraceDispatch[] =
     "[blink-gc] Missing dispatch to class %0 in manual trace dispatch.";
 
 const char kMissingFinalizeDispatch[] =
     "[blink-gc] Missing dispatch to class %0 in manual finalize dispatch.";
 
 const char kFinalizedFieldNote[] =
     "[blink-gc] Potentially finalized field %0 declared here:";
 
+const char kEagerlyFinalizedFieldNote[] =
+    "[blink-gc] Field %0 having eagerly finalized value, declared here:";
+
 const char kUserDeclaredDestructorNote[] =
     "[blink-gc] User-declared destructor declared here:";
 
 const char kUserDeclaredFinalizerNote[] =
     "[blink-gc] User-declared finalizer declared here:";
 
 const char kBaseRequiresFinalizationNote[] =
     "[blink-gc] Base class %0 requiring finalization declared here:";
 
 const char kFieldRequiresFinalizationNote[] =
@@ skipping 19 matching lines @@
     " 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*)";
 
+// Use a local RAV implementation to simply collect all FunctionDecls marked for
+// late template parsing. This happens with the flag -fdelayed-template-parsing,
+// which is on by default in MSVC-compatible mode.
+std::set<FunctionDecl*> GetLateParsedFunctionDecls(TranslationUnitDecl* decl) {
+  struct Visitor : public RecursiveASTVisitor<Visitor> {
+    bool VisitFunctionDecl(FunctionDecl* function_decl) {
+      if (function_decl->isLateTemplateParsed())
+        late_parsed_decls.insert(function_decl);
+      return true;
+    }
+
+    std::set<FunctionDecl*> late_parsed_decls;
+  } v;
+  v.TraverseDecl(decl);
+  return v.late_parsed_decls;
+}
+
 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 59 matching lines @@
 // either a Member, a heap-allocated collection or an off-heap collection that
 // contains Members.  Invalid uses are currently identified as passing the field
 // as the argument of a procedure call or using the -> or [] operators on it.
 class CheckFinalizerVisitor
     : public RecursiveASTVisitor<CheckFinalizerVisitor> {
  private:
   // Simple visitor to determine if the content of a field might be collected
   // during finalization.
   class MightBeCollectedVisitor : public EdgeVisitor {
    public:
-    MightBeCollectedVisitor() : might_be_collected_(false) {}
+    MightBeCollectedVisitor(bool is_eagerly_finalized)
+        : might_be_collected_(false)
+        , is_eagerly_finalized_(is_eagerly_finalized)
+        , as_eagerly_finalized_(false) {}
     bool might_be_collected() { return might_be_collected_; }
-    void VisitMember(Member* edge) override { might_be_collected_ = true; }
+    bool as_eagerly_finalized() { return as_eagerly_finalized_; }
+    void VisitMember(Member* edge) override {
+      if (is_eagerly_finalized_) {
+        if (edge->ptr()->IsValue()) {
+          Value* member = static_cast<Value*>(edge->ptr());
+          if (member->value()->IsEagerlyFinalized()) {
+            might_be_collected_ = true;
+            as_eagerly_finalized_ = true;
+          }
+        }
+        return;
+      }
+      might_be_collected_ = true;
+    }
     void VisitCollection(Collection* edge) override {
-      if (edge->on_heap()) {
+      if (edge->on_heap() && !is_eagerly_finalized_) {
         might_be_collected_ = !edge->is_root();
       } else {
         edge->AcceptMembers(this);
       }
     }
 
    private:
     bool might_be_collected_;
+    bool is_eagerly_finalized_;
+    bool as_eagerly_finalized_;
   };
 
  public:
-  typedef std::vector<std::pair<MemberExpr*, FieldPoint*> > Errors;
+  class Error {
+  public:
+    Error(MemberExpr *member,
+          bool as_eagerly_finalized,
+          FieldPoint* field)
+        : member_(member)
+        , as_eagerly_finalized_(as_eagerly_finalized)
+        , field_(field) {}
 
-  CheckFinalizerVisitor(RecordCache* cache)
-      : blacklist_context_(false), cache_(cache) {}
+    MemberExpr* member_;
+    bool as_eagerly_finalized_;
+    FieldPoint* field_;
+  };
+
+  typedef std::vector<Error> Errors;
+
+  CheckFinalizerVisitor(RecordCache* cache, bool is_eagerly_finalized)
+      : blacklist_context_(false)
+      , cache_(cache)
+      , is_eagerly_finalized_(is_eagerly_finalized) {}
 
   Errors& finalized_fields() { return finalized_fields_; }
 
   bool WalkUpFromCXXOperatorCallExpr(CXXOperatorCallExpr* expr) {
     // Only continue the walk-up if the operator is a blacklisted one.
     switch (expr->getOperator()) {
       case OO_Arrow:
       case OO_Subscript:
         this->WalkUpFromCallExpr(expr);
       default:
@@ skipping 17 matching lines @@
       return true;
 
     RecordInfo* info = cache_->Lookup(field->getParent());
     if (!info)
       return true;
 
     RecordInfo::Fields::iterator it = info->GetFields().find(field);
     if (it == info->GetFields().end())
       return true;
 
-    if (blacklist_context_ && MightBeCollected(&it->second))
-      finalized_fields_.push_back(std::make_pair(member, &it->second));
+    if (seen_members_.find(member) != seen_members_.end())
+      return true;
+
+    bool as_eagerly_finalized = false;
+    if (blacklist_context_ &&
+        MightBeCollected(&it->second, as_eagerly_finalized)) {
+      finalized_fields_.push_back(
+          Error(member, as_eagerly_finalized, &it->second));
+      seen_members_.insert(member);
+    }
     return true;
   }
 
-  bool MightBeCollected(FieldPoint* point) {
-    MightBeCollectedVisitor visitor;
+  bool MightBeCollected(FieldPoint* point, bool& as_eagerly_finalized) {
+    MightBeCollectedVisitor visitor(is_eagerly_finalized_);
     point->edge()->Accept(&visitor);
+    as_eagerly_finalized = visitor.as_eagerly_finalized();
     return visitor.might_be_collected();
   }
 
  private:
   bool blacklist_context_;
   Errors finalized_fields_;
+  std::set<MemberExpr*> seen_members_;
   RecordCache* cache_;
+  bool is_eagerly_finalized_;
 };
 
 // This visitor checks that a method contains within its body, a call to a
 // method on the provided receiver class. This is used to check manual
 // dispatching for trace and finalize methods.
 class CheckDispatchVisitor : public RecursiveASTVisitor<CheckDispatchVisitor> {
  public:
   CheckDispatchVisitor(RecordInfo* receiver)
       : receiver_(receiver), dispatched_to_receiver_(false) {}
 
@@ skipping 465 matching lines @@
 // - 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,
     kOwnPtrToGCManaged,
+    kMemberToGCUnmanaged,
     kMemberInUnmanaged,
     kPtrFromHeapToStack,
     kGCDerivedPartObject
   };
 
   typedef std::vector<std::pair<FieldPoint*, Error> > Errors;
 
   CheckFieldsVisitor(const BlinkGCPluginOptions& options)
       : options_(options), current_(0), stack_allocated_host_(false) {}
 
@@ skipping 38 matching lines @@
       return;
     }
 
     if (!Parent() &&
         edge->value()->IsGCDerived() &&
         !edge->value()->IsGCMixin()) {
       invalid_fields_.push_back(std::make_pair(current_, kGCDerivedPartObject));
       return;
     }
 
+    // If in a stack allocated context, be fairly insistent that T in Member<T>
+    // is GC allocated, as stack allocated objects do not have a trace()
+    // that separately verifies the validity of Member<T>.
+    //
+    // Notice that an error is only reported if T's definition is in scope;
+    // we do not require that it must be brought into scope as that would
+    // prevent declarations of mutually dependent class types.
+    //
+    // (Note: Member<>'s constructor will at run-time verify that the
+    // pointer it wraps is indeed heap allocated.)
+    if (stack_allocated_host_ && Parent() && Parent()->IsMember() &&
+        edge->value()->HasDefinition() && !edge->value()->IsGCAllocated()) {
+      invalid_fields_.push_back(std::make_pair(current_,
+                                               kMemberToGCUnmanaged));
+      return;
+    }
+
     if (!Parent() || !edge->value()->IsGCAllocated())
       return;
 
     // In transition mode, disallow  OwnPtr<T>, RawPtr<T> to GC allocated T's,
     // 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(
@@ skipping 91 matching lines @@
     diag_class_contains_invalid_fields_warning_ = diagnostic_.getCustomDiagID(
         DiagnosticsEngine::Warning, 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);
+    diag_finalizer_eagerly_finalized_field_ = diagnostic_.getCustomDiagID(
+        getErrorLevel(), kFinalizerAccessesEagerlyFinalizedField);
     diag_overridden_non_virtual_trace_ = diagnostic_.getCustomDiagID(
         getErrorLevel(), kOverriddenNonVirtualTrace);
     diag_missing_trace_dispatch_method_ = diagnostic_.getCustomDiagID(
         getErrorLevel(), kMissingTraceDispatchMethod);
     diag_missing_finalize_dispatch_method_ = diagnostic_.getCustomDiagID(
         getErrorLevel(), kMissingFinalizeDispatchMethod);
     diag_virtual_and_manual_dispatch_ =
         diagnostic_.getCustomDiagID(getErrorLevel(), kVirtualAndManualDispatch);
     diag_missing_trace_dispatch_ =
         diagnostic_.getCustomDiagID(getErrorLevel(), kMissingTraceDispatch);
@@ skipping 17 matching lines @@
     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_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);
     diag_part_object_contains_gc_root_note_ = diagnostic_.getCustomDiagID(
         DiagnosticsEngine::Note, kPartObjectContainsGCRootNote);
     diag_field_contains_gc_root_note_ = diagnostic_.getCustomDiagID(
         DiagnosticsEngine::Note, kFieldContainsGCRootNote);
     diag_finalized_field_note_ = diagnostic_.getCustomDiagID(
         DiagnosticsEngine::Note, kFinalizedFieldNote);
+    diag_eagerly_finalized_field_note_ = diagnostic_.getCustomDiagID(
+        DiagnosticsEngine::Note, kEagerlyFinalizedFieldNote);
     diag_user_declared_destructor_note_ = diagnostic_.getCustomDiagID(
         DiagnosticsEngine::Note, kUserDeclaredDestructorNote);
     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);
   }
 
   void HandleTranslationUnit(ASTContext& context) override {
     // Don't run the plugin if the compilation unit is already invalid.
     if (diagnostic_.hasErrorOccurred())
       return;
 
+    ParseFunctionTemplates(context.getTranslationUnitDecl());
+
     CollectVisitor visitor;
     visitor.TraverseDecl(context.getTranslationUnitDecl());
 
     if (options_.dump_graph) {
       std::error_code err;
       // TODO: Make createDefaultOutputFile or a shorter createOutputFile work.
       json_ = JsonWriter::from(instance_.createOutputFile(
           "",                                      // OutputPath
           err,                                     // Errors
           true,                                    // Binary
@@ skipping 26 matching lines @@
       CheckTracingMethod(*it);
     }
 
     if (json_) {
       json_->CloseList();
       delete json_;
       json_ = 0;
     }
   }
 
+  void ParseFunctionTemplates(TranslationUnitDecl* decl) {
+    if (!instance_.getLangOpts().DelayedTemplateParsing)
+      return;  // Nothing to do.
+
+    std::set<FunctionDecl*> late_parsed_decls =
+        GetLateParsedFunctionDecls(decl);
+    clang::Sema& sema = instance_.getSema();
+
+    for (const FunctionDecl* fd : late_parsed_decls) {
+      assert(fd->isLateTemplateParsed());
+
+      if (!Config::IsTraceMethod(fd))
+        continue;
+
+      if (instance_.getSourceManager().isInSystemHeader(
+              instance_.getSourceManager().getSpellingLoc(fd->getLocation())))
+        continue;
+
+      // Force parsing and AST building of the yet-uninstantiated function
+      // template trace method bodies.
+      clang::LateParsedTemplate* lpt = sema.LateParsedTemplateMap[fd];
+      sema.LateTemplateParser(sema.OpaqueParser, *lpt);
+    }
+  }
+
   // Main entry for checking a record declaration.
   void CheckRecord(RecordInfo* info) {
     if (IsIgnored(info))
       return;
 
     CXXRecordDecl* record = info->record();
 
     // TODO: what should we do to check unions?
     if (record->isUnion())
       return;
@@ skipping 257 matching lines @@
     }
   }
 
   // TODO: Should we collect destructors similar to trace methods?
   void CheckFinalization(RecordInfo* info) {
     CXXDestructorDecl* dtor = info->record()->getDestructor();
 
     // For finalized classes, check the finalization method if possible.
     if (info->IsGCFinalized()) {
       if (dtor && dtor->hasBody()) {
-        CheckFinalizerVisitor visitor(&cache_);
+        CheckFinalizerVisitor visitor(&cache_, info->IsEagerlyFinalized());
         visitor.TraverseCXXMethodDecl(dtor);
         if (!visitor.finalized_fields().empty()) {
           ReportFinalizerAccessesFinalizedFields(
               dtor, &visitor.finalized_fields());
         }
       }
       return;
     }
 
     // Don't require finalization of a mixin that has not yet been "mixed in".
@@ skipping 249 matching lines @@
     if (info->name().compare(0, SameSizeAs.size(), SameSizeAs) == 0)
       return true;
     return options_.ignored_classes.find(info->name()) !=
            options_.ignored_classes.end();
   }
 
   bool InIgnoredDirectory(RecordInfo* info) {
     string filename;
     if (!GetFilename(info->record()->getLocStart(), &filename))
       return false;  // TODO: should we ignore non-existing file locations?
+#if defined(LLVM_ON_WIN32)
+    std::replace(filename.begin(), filename.end(), '\\', '/');
+#endif
     std::vector<string>::iterator it = options_.ignored_directories.begin();
     for (; it != options_.ignored_directories.end(); ++it)
       if (filename.find(*it) != string::npos)
         return true;
     return false;
   }
 
   bool InCheckedNamespace(RecordInfo* info) {
     if (!info)
       return false;
@@ skipping 97 matching lines @@
          it != errors->end();
          ++it) {
       unsigned error;
       if (it->second == CheckFieldsVisitor::kRawPtrToGCManaged ||
           it->second == CheckFieldsVisitor::kRawPtrToGCManagedWarning) {
         error = diag_raw_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_;
       } else if (it->second == CheckFieldsVisitor::kGCDerivedPartObject) {
         error = diag_part_object_to_gc_derived_class_note_;
       } else {
         assert(false && "Unknown field error");
       }
       NoteField(it->first, error);
@@ skipping 19 matching lines @@
       NoteFieldContainsGCRoot(point);
     }
   }
 
   void ReportFinalizerAccessesFinalizedFields(
       CXXMethodDecl* dtor,
       CheckFinalizerVisitor::Errors* fields) {
     for (CheckFinalizerVisitor::Errors::iterator it = fields->begin();
          it != fields->end();
          ++it) {
-      SourceLocation loc = it->first->getLocStart();
+      SourceLocation loc = it->member_->getLocStart();
       SourceManager& manager = instance_.getSourceManager();
+      bool as_eagerly_finalized = it->as_eagerly_finalized_;
+      unsigned diag_error = as_eagerly_finalized ?
+          diag_finalizer_eagerly_finalized_field_ :
+          diag_finalizer_accesses_finalized_field_;
+      unsigned diag_note = as_eagerly_finalized ?
+          diag_eagerly_finalized_field_note_ :
+          diag_finalized_field_note_;
       FullSourceLoc full_loc(loc, manager);
-      diagnostic_.Report(full_loc, diag_finalizer_accesses_finalized_field_)
-          << dtor << it->second->field();
-      NoteField(it->second, diag_finalized_field_note_);
+      diagnostic_.Report(full_loc, diag_error)
+          << dtor << it->field_->field();
+      NoteField(it->field_, diag_note);
     }
   }
 
   void ReportClassRequiresFinalization(RecordInfo* info) {
     SourceLocation loc = info->record()->getInnerLocStart();
     SourceManager& manager = instance_.getSourceManager();
     FullSourceLoc full_loc(loc, manager);
     diagnostic_.Report(full_loc, diag_class_requires_finalization_)
         << info->record();
   }
@@ skipping 188 matching lines @@
   unsigned diag_class_must_left_mostly_derive_gc_;
   unsigned diag_class_requires_trace_method_;
   unsigned diag_base_requires_tracing_;
   unsigned diag_fields_require_tracing_;
   unsigned diag_class_contains_invalid_fields_;
   unsigned diag_class_contains_invalid_fields_warning_;
   unsigned diag_class_contains_gc_root_;
   unsigned diag_class_requires_finalization_;
   unsigned diag_class_does_not_require_finalization_;
   unsigned diag_finalizer_accesses_finalized_field_;
+  unsigned diag_finalizer_eagerly_finalized_field_;
   unsigned diag_overridden_non_virtual_trace_;
   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_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_;
   unsigned diag_user_declared_finalizer_note_;
   unsigned diag_base_requires_finalization_note_;
   unsigned diag_field_requires_finalization_note_;
   unsigned diag_overridden_non_virtual_trace_note_;
   unsigned diag_manual_dispatch_method_note_;
 
   CompilerInstance& instance_;
   DiagnosticsEngine& diagnostic_;
   BlinkGCPluginOptions options_;
@@ skipping 37 matching lines @@
 
  private:
   BlinkGCPluginOptions options_;
 };
 
 }  // namespace
 
 static FrontendPluginRegistry::Add<BlinkGCPluginAction> X(
     "blink-gc-plugin",
     "Check Blink GC invariants");