Blink GC plugin: improve handling of type dependent bases.

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 382 matching lines @@
 
   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();
     CXXRecordDecl* tmpl = GetDependentTemplatedDecl(expr);
     if (!tmpl)
       return;
 
     // Check for Super<T>::trace(visitor)
@@ skipping 612 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 746 matching lines @@
 
  private:
   BlinkGCPluginOptions options_;
 };
 
 }  // namespace
 
 static FrontendPluginRegistry::Add<BlinkGCPluginAction> X(
     "blink-gc-plugin",
     "Check Blink GC invariants");