Update from https://crrev.com/309717

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 179 matching lines @@
 
   // Collect record declarations, including nested declarations.
   bool VisitCXXRecordDecl(CXXRecordDecl* record) {
     if (record->hasDefinition() && record->isCompleteDefinition())
       record_decls_.push_back(record);
     return true;
   }
 
   // Collect tracing method definitions, but don't traverse method bodies.
   bool TraverseCXXMethodDecl(CXXMethodDecl* method) {
-    if (method->isThisDeclarationADefinition() && Config::IsTraceMethod(method))
+    if (method->isThisDeclarationADefinition() &&
+        Config::IsTraceMethod(method, nullptr))
       trace_decls_.push_back(method);
     return true;
   }
 
  private:
   RecordVector record_decls_;
   MethodVector trace_decls_;
 };
 
 // This visitor checks that a finalizer method does not have invalid access to
@@ skipping 104 matching lines @@
   RecordInfo* receiver_;
   bool dispatched_to_receiver_;
 };
 
 // This visitor checks a tracing method by traversing its body.
 // - A member field is considered traced if it is referenced in the body.
 // - A base is traced if a base-qualified call to a trace method is found.
 class CheckTraceVisitor : public RecursiveASTVisitor<CheckTraceVisitor> {
  public:
   CheckTraceVisitor(CXXMethodDecl* trace, RecordInfo* info)
-      : trace_(trace), info_(info) {}
+      : trace_(trace), info_(info), delegates_to_traceimpl_(false) {}
+
+  bool delegates_to_traceimpl() const { return delegates_to_traceimpl_; }
 
   bool VisitMemberExpr(MemberExpr* member) {
     // In weak callbacks, consider any occurrence as a correct usage.
     // TODO: We really want to require that isAlive is checked on manually
     // processed weak fields.
     if (IsWeakCallback()) {
       if (FieldDecl* field = dyn_cast<FieldDecl>(member->getMemberDecl()))
         FoundField(field);
     }
     return true;
@@ skipping 40 matching lines @@
         return true;
       CXXRecordDecl* decl = base->getPointeeType()->getAsCXXRecordDecl();
       if (decl)
         CheckTraceFieldCall(expr->getMemberName().getAsString(), decl, arg);
       return true;
     }
 
     if (CXXMemberCallExpr* expr = dyn_cast<CXXMemberCallExpr>(call)) {
       if (CheckTraceFieldCall(expr) || CheckRegisterWeakMembers(expr))
         return true;
+
+      if (expr->getMethodDecl()->getNameAsString() == kTraceImplName) {
+        delegates_to_traceimpl_ = true;
+        return true;
+      }
     }
 
     CheckTraceBaseCall(call);
     return true;
   }
 
  private:
 
   CXXRecordDecl* GetDependentTemplatedDecl(CXXDependentScopeMemberExpr* expr) {
     NestedNameSpecifier* qual = expr->getQualifier();
     if (!qual)
       return 0;
 
     const Type* type = qual->getAsType();
     if (!type)
       return 0;
 
-    const TemplateSpecializationType* tmpl_type =
-        type->getAs<TemplateSpecializationType>();
-    if (!tmpl_type)
-      return 0;
-
-    TemplateDecl* tmpl_decl = tmpl_type->getTemplateName().getAsTemplateDecl();
-    if (!tmpl_decl)
-      return 0;
-
-    return dyn_cast<CXXRecordDecl>(tmpl_decl->getTemplatedDecl());
+    return RecordInfo::GetDependentTemplatedDecl(*type);
   }
 
   void CheckCXXDependentScopeMemberExpr(CallExpr* call,
                                         CXXDependentScopeMemberExpr* expr) {
     string fn_name = expr->getMember().getAsString();
+
+    // Check for VisitorDispatcher::trace(field)
+    if (!expr->isImplicitAccess()) {
+      if (clang::DeclRefExpr* base_decl =
+              clang::dyn_cast<clang::DeclRefExpr>(expr->getBase())) {
+        if (Config::IsVisitorDispatcherType(base_decl->getType()) &&
+            call->getNumArgs() == 1 && fn_name == kTraceName) {
+          FindFieldVisitor finder;
+          finder.TraverseStmt(call->getArg(0));
+          if (finder.field())
+            FoundField(finder.field());
+
+          return;
+        }
+      }
+    }
+
     CXXRecordDecl* tmpl = GetDependentTemplatedDecl(expr);
     if (!tmpl)
       return;
 
     // Check for Super<T>::trace(visitor)
     if (call->getNumArgs() == 1 && fn_name == trace_->getName()) {
       RecordInfo::Bases::iterator it = info_->GetBases().begin();
       for (; it != info_->GetBases().end(); ++it) {
         if (it->first->getName() == tmpl->getName())
           it->second.MarkTraced();
@@ skipping 10 matching lines @@
         FoundField(finder.field());
     }
   }
 
   bool CheckTraceBaseCall(CallExpr* call) {
     MemberExpr* callee = dyn_cast<MemberExpr>(call->getCallee());
     if (!callee)
       return false;
 
     FunctionDecl* fn = dyn_cast<FunctionDecl>(callee->getMemberDecl());
-    if (!fn || !Config::IsTraceMethod(fn))
+    if (!fn || !Config::IsTraceMethod(fn, nullptr))
       return false;
 
     // Currently, a manually dispatched class cannot have mixin bases (having
     // one would add a vtable which we explicitly check against). This means
     // that we can only make calls to a trace method of the same name. Revisit
     // this if our mixin/vtable assumption changes.
     if (fn->getName() != trace_->getName())
       return false;
 
     CXXRecordDecl* decl = 0;
@@ skipping 99 matching lines @@
       }
     } else {
       RecordInfo::Fields::iterator it = info_->GetFields().find(field);
       if (it != info_->GetFields().end())
         MarkTraced(it);
     }
   }
 
   CXXMethodDecl* trace_;
   RecordInfo* info_;
+  bool delegates_to_traceimpl_;
 };
 
 // This visitor checks that the fields of a class and the fields of
 // its part objects don't define GC roots.
 class CheckGCRootsVisitor : public RecursiveEdgeVisitor {
  public:
   typedef std::vector<FieldPoint*> RootPath;
   typedef std::set<RecordInfo*> VisitingSet;
   typedef std::vector<RootPath> Errors;
 
@@ skipping 457 matching lines @@
   // ensure that the left-most base defines a vtable. This ensures that the
   // first thing to be initialized when constructing the object is the vtable
   // itself.
   void CheckPolymorphicClass(RecordInfo* info, CXXMethodDecl* trace) {
     CXXRecordDecl* left_most = info->record();
     CXXRecordDecl::base_class_iterator it = left_most->bases_begin();
     CXXRecordDecl* left_most_base = 0;
     while (it != left_most->bases_end()) {
       left_most_base = it->getType()->getAsCXXRecordDecl();
       if (!left_most_base && it->getType()->isDependentType())
-        left_most_base = GetDependentTemplatedDecl(*it->getType());
+        left_most_base = RecordInfo::GetDependentTemplatedDecl(*it->getType());
 
       // TODO: Find a way to correctly check actual instantiations
       // for dependent types. The escape below will be hit, eg, when
       // we have a primary template with no definition and
       // specializations for each case (such as SupplementBase) in
       // which case we don't succeed in checking the required
       // properties.
       if (!left_most_base || !left_most_base->hasDefinition())
         return;
 
@@ skipping 40 matching lines @@
         }
       }
       ReportLeftMostBaseMustBePolymorphic(info, left_most);
     }
   }
 
   CXXRecordDecl* GetLeftMostBase(CXXRecordDecl* left_most) {
     CXXRecordDecl::base_class_iterator it = left_most->bases_begin();
     while (it != left_most->bases_end()) {
       if (it->getType()->isDependentType())
-        left_most = GetDependentTemplatedDecl(*it->getType());
+        left_most = RecordInfo::GetDependentTemplatedDecl(*it->getType());
       else
         left_most = it->getType()->getAsCXXRecordDecl();
       if (!left_most || !left_most->hasDefinition())
         return 0;
       it = left_most->bases_begin();
     }
     return left_most;
   }
 
   bool DeclaresVirtualMethods(CXXRecordDecl* decl) {
     CXXRecordDecl::method_iterator it = decl->method_begin();
     for (; it != decl->method_end(); ++it)
       if (it->isVirtual() && !it->isPure())
         return true;
     return false;
   }
 
   void CheckLeftMostDerived(RecordInfo* info) {
-    CXXRecordDecl* left_most = info->record();
-    CXXRecordDecl::base_class_iterator it = left_most->bases_begin();
-    while (it != left_most->bases_end()) {
-      left_most = it->getType()->getAsCXXRecordDecl();
-      it = left_most->bases_begin();
-    }
+    CXXRecordDecl* left_most = GetLeftMostBase(info->record());
+    if (!left_most)
+      return;
     if (!Config::IsGCBase(left_most->getName()))
       ReportClassMustLeftMostlyDeriveGC(info);
   }
 
   void CheckDispatch(RecordInfo* info) {
     bool finalized = info->IsGCFinalized();
     CXXMethodDecl* trace_dispatch = info->GetTraceDispatchMethod();
     CXXMethodDecl* finalize_dispatch = info->GetFinalizeDispatchMethod();
     if (!trace_dispatch && !finalize_dispatch)
       return;
@@ skipping 155 matching lines @@
            ++it) {
         RecordInfo* base = it->second.info();
         if (CXXMethodDecl* other = base->InheritsNonVirtualTrace())
           ReportOverriddenNonVirtualTrace(parent, trace, other);
       }
     }
 
     CheckTraceVisitor visitor(trace, parent);
     visitor.TraverseCXXMethodDecl(trace);
 
+    // Skip reporting if this trace method is a just delegate to
+    // traceImpl method. We will report on CheckTraceMethod on traceImpl method.
+    if (visitor.delegates_to_traceimpl())
+      return;
+
     for (RecordInfo::Bases::iterator it = parent->GetBases().begin();
          it != parent->GetBases().end();
          ++it) {
       if (!it->second.IsProperlyTraced())
         ReportBaseRequiresTracing(parent, trace, it->first);
     }
 
     for (RecordInfo::Fields::iterator it = parent->GetFields().begin();
          it != parent->GetFields().end();
          ++it) {
@@ skipping 571 matching lines @@
 
  private:
   BlinkGCPluginOptions options_;
 };
 
 }  // namespace
 
 static FrontendPluginRegistry::Add<BlinkGCPluginAction> X(
     "blink-gc-plugin",
     "Check Blink GC invariants");