[clang] NFC: rename internal `IsPossiblyOpaquelyQualifiedType` overload

[mizvekov]

Summary

Rename IsPossiblyOpaquelyQualifiedType overload taking a Type*
as IsPossiblyOpaquelyQualifiedTypeInternal instead.

Signed-off-by: Matheus Izvekov <[e-mail]>

[mizvekov]

.

clang/lib/Sema/SemaTemplateDeduction.cpp

if (auto Result = DeduceTemplateArguments(
     return Result;
 
   // Perform template argument deduction for the template arguments.
   return DeduceTemplateArguments(S, TemplateParams, PResolved,
                                  SA->getTemplateArgs().asArray(), Info, Deduced,
                                  /*NumberOfArgumentsMustMatch=*/true);
 }
 
-static bool IsPossiblyOpaquelyQualifiedType(const Type *T) {
+static bool IsPossiblyOpaquelyQualifiedTypeInternal(const Type *T) {
   assert(T->isCanonicalUnqualified());
 
   switch (T->getTypeClass()) {
   case Type::TypeOfExpr:
   case Type::TypeOf:
   case Type::DependentName:
   case Type::Decltype:
   case Type::UnresolvedUsing:
   case Type::TemplateTypeParm:
     return true;
 
   case Type::ConstantArray:
   case Type::IncompleteArray:
   case Type::VariableArray:
   case Type::DependentSizedArray:
-    return IsPossiblyOpaquelyQualifiedType(
+    return IsPossiblyOpaquelyQualifiedTypeInternal(
         cast<ArrayType>(T)->getElementType().getTypePtr());
 
   default:
     return false;
   }
 }
 
 /// Determines whether the given type is an opaque type that
 /// might be more qualified when instantiated.
 static bool IsPossiblyOpaquelyQualifiedType(QualType T) {
-  return IsPossiblyOpaquelyQualifiedType(
+  return IsPossiblyOpaquelyQualifiedTypeInternal(
       T->getCanonicalTypeInternal().getTypePtr());
 }
 
 /// Helper function to build a TemplateParameter when we don't
 /// know its type statically.
 static TemplateParameter makeTemplateParameter(Decl *D) {
   if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(D))
     return TemplateParameter(TTP);