Rename getPointeeOrArrayElementType()

Author: Sirraide

clang-tools-extra/clang-tidy/bugprone/SuspiciousMemoryComparisonCheck.cpp

@@ -45,7 +45,7 @@ void SuspiciousMemoryComparisonCheck::check(
   for (unsigned int ArgIndex = 0; ArgIndex < 2; ++ArgIndex) {
     const Expr *ArgExpr = CE->getArg(ArgIndex);
     QualType ArgType = ArgExpr->IgnoreImplicit()->getType();
-    const Type *PointeeType = ArgType->getPointeeOrArrayElementType();
+    const Type *PointeeType = ArgType->getPointerOrObjCPointerOrArrayElementType();
     assert(PointeeType != nullptr && "PointeeType should always be available.");
     QualType PointeeQualifiedType(PointeeType, 0);
 

clang-tools-extra/clang-tidy/mpi/TypeMismatchCheck.cpp

@@ -229,7 +229,7 @@ static bool isTypedefTypeMatching(const TypedefType *const Typedef,
 /// \returns type of the argument
 static const Type *argumentType(const CallExpr *const CE, const size_t Idx) {
   const QualType QT = CE->getArg(Idx)->IgnoreImpCasts()->getType();
-  return QT.getTypePtr()->getPointeeOrArrayElementType();
+  return QT.getTypePtr()->getPointerOrObjCPointerOrArrayElementType();
 }
 
 void TypeMismatchCheck::registerMatchers(MatchFinder *Finder) {

clang-tools-extra/clangd/SemanticHighlighting.cpp

@@ -296,7 +296,7 @@ bool isDefaultLibrary(const Decl *D) {
 bool isDefaultLibrary(const Type *T) {
   if (!T)
     return false;
-  const Type *Underlying = T->getPointeeOrArrayElementType();
+  const Type *Underlying = T->getPointerOrObjCPointerOrArrayElementType();
   if (Underlying->isBuiltinType())
     return true;
   if (auto *TD = dyn_cast<TemplateTypeParmType>(Underlying))

clang/include/clang/AST/Type.h

@@ -2863,10 +2863,13 @@ class alignas(TypeAlignment) Type : public ExtQualsTypeCommonBase {
   /// This should never be used when type qualifiers are meaningful.
   const Type *getArrayElementTypeNoTypeQual() const;
 
-  /// If this is a pointer type, return the pointee type.
+  /// If this is a C or ObjC pointer type, return the pointee type. Notably,
+  /// this does not handle things like member pointers or block pointers.
+  ///
   /// If this is an array type, return the array element type.
+  ///
   /// This should never be used when type qualifiers are meaningful.
-  const Type *getPointeeOrArrayElementType() const;
+  const Type *getPointerOrObjCPointerOrArrayElementType() const;
 
   /// If this is a pointer, ObjC object pointer, or block
   /// pointer, this returns the respective pointee.
@@ -8691,7 +8694,7 @@ inline const Type *Type::getBaseElementTypeUnsafe() const {
   return type;
 }
 
-inline const Type *Type::getPointeeOrArrayElementType() const {
+inline const Type *Type::getPointerOrObjCPointerOrArrayElementType() const {
   const Type *type = this;
   if (type->isPointerOrObjCObjectPointerType())
     return type->getPointeeType().getTypePtr();

clang/lib/AST/ASTImporter.cpp

@@ -1942,7 +1942,7 @@ Error ASTNodeImporter::ImportDeclParts(
       FunDecl->hasBody()) {
     auto getLeafPointeeType = [](const Type *T) {
       while (T->isPointerType() || T->isArrayType()) {
-        T = T->getPointeeOrArrayElementType();
+        T = T->getPointerOrObjCPointerOrArrayElementType();
       }
       return T;
     };

clang/lib/CodeGen/CGExpr.cpp

@@ -991,7 +991,7 @@ static llvm::Value *getArrayIndexingBound(CodeGenFunction &CGF,
 
   CodeGenFunction::SanitizerScope SanScope(&CGF);
 
-  QualType EltTy{Base->getType()->getPointeeOrArrayElementType(), 0};
+  QualType EltTy{Base->getType()->getPointerOrObjCPointerOrArrayElementType(), 0};
   if (llvm::Value *POS = CGF.LoadPassedObjectSize(Base, EltTy)) {
     IndexedType = Base->getType();
     return POS;

clang/lib/CodeGen/CGHLSLRuntime.cpp

@@ -290,7 +290,7 @@ calculateElementType(const ASTContext &Context, const clang::Type *ResourceTy) {
 }
 
 void CGHLSLRuntime::annotateHLSLResource(const VarDecl *D, GlobalVariable *GV) {
-  const Type *Ty = D->getType()->getPointeeOrArrayElementType();
+  const Type *Ty = D->getType()->getPointerOrObjCPointerOrArrayElementType();
   if (!Ty)
     return;
   const auto *RD = Ty->getAsCXXRecordDecl();

clang/lib/CodeGen/CGOpenMPRuntime.cpp

@@ -7551,7 +7551,7 @@ class MappableExprsHandler {
           // For the case that having pointer as base, we need to remove one
           // level of indirection.
           if (&Component != &*Components.begin())
-            ElementType = ElementType->getPointeeOrArrayElementType();
+            ElementType = ElementType->getPointerOrObjCPointerOrArrayElementType();
           ElementTypeSize =
               Context.getTypeSizeInChars(ElementType).getQuantity();
           CurStrides.push_back(
@@ -8628,10 +8628,10 @@ class MappableExprsHandler {
     llvm::SmallVector<const FieldDecl *, 4> Layout;
     if (!OverlappedData.empty()) {
       const Type *BaseType = VD->getType().getCanonicalType().getTypePtr();
-      const Type *OrigType = BaseType->getPointeeOrArrayElementType();
+      const Type *OrigType = BaseType->getPointerOrObjCPointerOrArrayElementType();
       while (BaseType != OrigType) {
         BaseType = OrigType->getCanonicalTypeInternal().getTypePtr();
-        OrigType = BaseType->getPointeeOrArrayElementType();
+        OrigType = BaseType->getPointerOrObjCPointerOrArrayElementType();
       }
 
       if (const auto *CRD = BaseType->getAsCXXRecordDecl())

clang/lib/CodeGen/Targets/SystemZ.cpp

@@ -503,7 +503,7 @@ bool SystemZTargetCodeGenInfo::isVectorTypeBased(const Type *Ty,
 
   // Assume pointers are dereferenced.
   while (Ty->isPointerType() || Ty->isArrayType())
-    Ty = Ty->getPointeeOrArrayElementType();
+    Ty = Ty->getPointerOrObjCPointerOrArrayElementType();
 
   // Vectors >= 16 bytes expose the ABI through alignment requirements.
   if (Ty->isVectorType() && Ctx.getTypeSize(Ty) / 8 >= 16)

clang/lib/Sema/SemaChecking.cpp

@@ -13424,7 +13424,7 @@ void Sema::CheckArrayAccess(const Expr *BaseExpr, const Expr *IndexExpr,
     return;
 
   const Type *EffectiveType =
-      BaseExpr->getType()->getPointeeOrArrayElementType();
+      BaseExpr->getType()->getPointerOrObjCPointerOrArrayElementType();
   BaseExpr = BaseExpr->IgnoreParenCasts();
   const ConstantArrayType *ArrayTy =
       Context.getAsConstantArrayType(BaseExpr->getType());

clang/lib/Sema/SemaDecl.cpp

@@ -9541,7 +9541,7 @@ static OpenCLParamType getOpenCLKernelParameterType(Sema &S, QualType PT) {
 
   // Look into an array argument to check if it has a forbidden type.
   if (PT->isArrayType()) {
-    const Type *UnderlyingTy = PT->getPointeeOrArrayElementType();
+    const Type *UnderlyingTy = PT->getPointerOrObjCPointerOrArrayElementType();
     // Call ourself to check an underlying type of an array. Since the
     // getPointeeOrArrayElementType returns an innermost type which is not an
     // array, this recursive call only happens once.
@@ -9644,7 +9644,7 @@ static void checkIsValidOpenCLKernelParameter(
   // an ArrayType of a RecordType.
   assert((PT->isArrayType() || PT->isRecordType()) && "Unexpected type.");
   const RecordType *RecTy =
-      PT->getPointeeOrArrayElementType()->getAs<RecordType>();
+      PT->getPointerOrObjCPointerOrArrayElementType()->getAs<RecordType>();
   const RecordDecl *OrigRecDecl = RecTy->getDecl();
 
   VisitStack.push_back(RecTy->getDecl());
@@ -9672,7 +9672,7 @@ static void checkIsValidOpenCLKernelParameter(
       // walk around RecordDecl::fields().
       assert((FieldTy->isArrayType() || FieldTy->isRecordType()) &&
              "Unexpected type.");
-      const Type *FieldRecTy = FieldTy->getPointeeOrArrayElementType();
+      const Type *FieldRecTy = FieldTy->getPointerOrObjCPointerOrArrayElementType();
 
       RD = FieldRecTy->castAs<RecordType>()->getDecl();
     } else {

clang/lib/Sema/SemaExpr.cpp

@@ -17069,8 +17069,8 @@ bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy,
       return Type->isSpecificBuiltinType(BuiltinType::Char_S) ||
              Type->isSpecificBuiltinType(BuiltinType::Char_U);
     };
-    FDiag << (isPlainChar(FirstType->getPointeeOrArrayElementType()) ||
-              isPlainChar(SecondType->getPointeeOrArrayElementType()));
+    FDiag << (isPlainChar(FirstType->getPointerOrObjCPointerOrArrayElementType()) ||
+              isPlainChar(SecondType->getPointerOrObjCPointerOrArrayElementType()));
   }
 
   // If we can fix the conversion, suggest the FixIts.

clang/lib/Sema/SemaInit.cpp

@@ -7878,8 +7878,8 @@ ExprResult InitializationSequence::Perform(Sema &S,
       if (MTETy->isIncompleteArrayType() &&
           !CurInit.get()->getType()->isIncompleteArrayType() &&
           S.Context.hasSameType(
-              MTETy->getPointeeOrArrayElementType(),
-              CurInit.get()->getType()->getPointeeOrArrayElementType()))
+              MTETy->getPointerOrObjCPointerOrArrayElementType(),
+              CurInit.get()->getType()->getPointerOrObjCPointerOrArrayElementType()))
         MTETy = CurInit.get()->getType();
 
       // Materialize the temporary into memory.

clang/lib/Sema/SemaOpenCL.cpp

@@ -324,7 +324,7 @@ bool SemaOpenCL::checkBuiltinEnqueueKernel(CallExpr *TheCall) {
     // Fifth argument is always passed as a pointer to clk_event_t.
     if (!Arg4->isNullPointerConstant(Context,
                                      Expr::NPC_ValueDependentIsNotNull) &&
-        !Arg4->getType()->getPointeeOrArrayElementType()->isClkEventT()) {
+        !Arg4->getType()->getPointerOrObjCPointerOrArrayElementType()->isClkEventT()) {
       Diag(TheCall->getArg(4)->getBeginLoc(),
            diag::err_opencl_builtin_expected_type)
           << TheCall->getDirectCallee()