Check mutability recursively

Author: DKLoehr

clang/include/clang/AST/Type.h

@@ -1086,10 +1086,20 @@ class QualType {
   /// applied to this type.
   unsigned getCVRQualifiers() const;
 
+  // Determine whether the object seems constant (i.e., const-qualified)
   bool isConstant(const ASTContext& Ctx) const {
     return QualType::isConstant(*this, Ctx);
   }
 
+  // Determine whether the object seems mutable, (i.e. non-const-qualified, and
+  // not an always-constant type like a function).
+  // Not perfect: doesn't account for mutable members, for example, or
+  // elements of container types.
+  // For nested pointers, any individual level being non-const is sufficient.
+  bool isMutable(const ASTContext &Ctx) const {
+    return QualType::isMutable(*this, Ctx);
+  }
+
   /// Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
   bool isPODType(const ASTContext &Context) const;
 
@@ -1617,6 +1627,7 @@ class QualType {
   // "static"-ize them to avoid creating temporary QualTypes in the
   // caller.
   static bool isConstant(QualType T, const ASTContext& Ctx);
+  static bool isMutable(QualType T, const ASTContext &Ctx);
   static QualType getDesugaredType(QualType T, const ASTContext &Context);
   static SplitQualType getSplitDesugaredType(QualType T);
   static SplitQualType getSplitUnqualifiedTypeImpl(QualType type);

clang/lib/AST/Type.cpp

@@ -139,6 +139,17 @@ bool QualType::isConstant(QualType T, const ASTContext &Ctx) {
   return T.getAddressSpace() == LangAS::opencl_constant;
 }
 
+bool QualType::isMutable(QualType T, const ASTContext &Ctx) {
+  T = T.getNonReferenceType();
+  if (T->isFunctionType())
+    return false;
+  if (!T.isConstant(Ctx))
+    return true;
+  if (T->isPointerType())
+    return QualType::isMutable(T->getPointeeType(), Ctx);
+  return false;
+}
+
 std::optional<QualType::NonConstantStorageReason>
 QualType::isNonConstantStorage(const ASTContext &Ctx, bool ExcludeCtor,
                             bool ExcludeDtor) {

clang/lib/Sema/SemaDecl.cpp

@@ -13454,24 +13454,10 @@ void Sema::DiagnoseUniqueObjectDuplication(const VarDecl *VD) {
       !VD->isTemplated() &&
       GloballyUniqueObjectMightBeAccidentallyDuplicated(VD)) {
 
-    // Check mutability. For pointers, ensure that both the pointer and the
-    // pointee are (recursively) const.
-    QualType Type = VD->getType().getNonReferenceType();
-    if (!Type.isConstant(VD->getASTContext())) {
+    QualType Type = VD->getType();
+    if (Type.isMutable(VD->getASTContext())) {
       Diag(VD->getLocation(), diag::warn_possible_object_duplication_mutable)
           << VD;
-    } else {
-      while (Type->isPointerType()) {
-        Type = Type->getPointeeType();
-        if (Type->isFunctionType())
-          break;
-        if (!Type.isConstant(VD->getASTContext())) {
-          Diag(VD->getLocation(),
-               diag::warn_possible_object_duplication_mutable)
-              << VD;
-          break;
-        }
-      }
     }
 
     // To keep false positives low, only warn if we're certain that the