blink_gc_plugin: retire overloaded traceImpl detection and handling.

tools/clang/blink_gc_plugin/CheckTraceVisitor.cpp

 // Copyright 2015 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 "CheckTraceVisitor.h"
 
 #include <vector>
 
 #include "Config.h"
 
 using namespace clang;
 
 CheckTraceVisitor::CheckTraceVisitor(CXXMethodDecl* trace,
                                      RecordInfo* info,
                                      RecordCache* cache)
-    : trace_(trace),
-      info_(info),
-      cache_(cache),
-      delegates_to_traceimpl_(false) {
-}
-
-bool CheckTraceVisitor::delegates_to_traceimpl() const {
-  return delegates_to_traceimpl_;
-}
+    : trace_(trace), info_(info), cache_(cache) {}
 
 bool CheckTraceVisitor::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 30 matching lines @@
 
     if (expr->getMemberName().getAsString() == kRegisterWeakMembersName)
       MarkAllWeakMembersTraced();
 
     QualType base = expr->getBaseType();
     if (!base->isPointerType())
       return true;
     CXXRecordDecl* decl = base->getPointeeType()->getAsCXXRecordDecl();
     if (decl)
       CheckTraceFieldCall(expr->getMemberName().getAsString(), decl, arg);
-    if (Config::IsTraceImplName(expr->getMemberName().getAsString()))
-      delegates_to_traceimpl_ = true;
     return true;
   }
 
   if (CXXMemberCallExpr* expr = dyn_cast<CXXMemberCallExpr>(call)) {
     if (CheckTraceFieldMemberCall(expr) || CheckRegisterWeakMembers(expr))
       return true;
 
-    if (Config::IsTraceImplName(expr->getMethodDecl()->getNameAsString())) {
-      delegates_to_traceimpl_ = true;
-      return true;
-    }
   }
 
   CheckTraceBaseCall(call);
   return true;
 }
 
 bool CheckTraceVisitor::IsTraceCallName(const std::string& name) {
-  if (trace_->getName() == kTraceImplName)
-    return name == kTraceName;
-  if (trace_->getName() == kTraceAfterDispatchImplName)
-    return name == kTraceAfterDispatchName;
   // 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.
   return name == trace_->getName();
 }
 
 CXXRecordDecl* CheckTraceVisitor::GetDependentTemplatedDecl(
     CXXDependentScopeMemberExpr* expr) {
   NestedNameSpecifier* qual = expr->getQualifier();
@@ skipping 116 matching lines @@
     const Type* type = callee->getQualifier()->getAsType();
     if (!type)
       return false;
 
     callee_record = type->getAsCXXRecordDecl();
     func_name = trace_decl->getName();
   } else if (UnresolvedMemberExpr* callee =
              dyn_cast<UnresolvedMemberExpr>(call->getCallee())) {
     // Callee part may become unresolved if the type of the argument
     // ("visitor") is a template parameter and the called function is
-    // overloaded (i.e. trace(Visitor*) and
-    // trace(InlinedGlobalMarkingVisitor)).
+    // overloaded.
     //
     // Here, we try to find a function that looks like trace() from the
     // candidate overloaded functions, and if we find one, we assume it is
     // called here.
 
     CXXMethodDecl* trace_decl = nullptr;
     for (NamedDecl* named_decl : callee->decls()) {
       if (CXXMethodDecl* method_decl = dyn_cast<CXXMethodDecl>(named_decl)) {
         if (Config::IsTraceMethod(method_decl)) {
           trace_decl = method_decl;
@@ skipping 97 matching lines @@
     // The second template argument is the callback method.
     if (args.size() > 1 &&
         args[1].getKind() == TemplateArgument::Declaration) {
       if (FunctionDecl* callback =
           dyn_cast<FunctionDecl>(args[1].getAsDecl())) {
         if (callback->hasBody()) {
           CheckTraceVisitor nested_visitor(nullptr, info_, nullptr);
           nested_visitor.TraverseStmt(callback->getBody());
         }
       }
+      // TODO: mark all WeakMember<>s as traced even if
+      // the body isn't available?
     }
   }
   return true;
 }
 
 bool CheckTraceVisitor::IsWeakCallback() const {
   return !trace_;
 }
 
 void CheckTraceVisitor::MarkTraced(RecordInfo::Fields::iterator it) {
@@ skipping 26 matching lines @@
 
 void CheckTraceVisitor::MarkAllWeakMembersTraced() {
   // If we find a call to registerWeakMembers which is unresolved we
   // unsoundly consider all weak members as traced.
   // TODO: Find out how to validate weak member tracing for unresolved call.
   for (auto& field : info_->GetFields()) {
     if (field.second.edge()->IsWeakMember())
       field.second.MarkTraced();
   }
 }