[clang] Fix __is_trivially_equality_comparable for classes which contain arrays of non-trivially equality comparable types

[philnik]

Summary

Fixes #63656

[cor3ntin]

LGTM, thanks!

[tbaeder]

clang/lib/AST/Type.cpp

2676

clang/lib/AST/Type.cpp

HasNonDeletedDefaultedEqualityComparison(const CXXRecordDecl *Decl) {
   return llvm::all_of(Decl->bases(),
                       [](const CXXBaseSpecifier &BS) {
                         if (const auto *RD = BS.getType()->getAsCXXRecordDecl())
                           return HasNonDeletedDefaultedEqualityComparison(RD);
                         return true;
                       }) &&
          llvm::all_of(Decl->fields(), [](const FieldDecl *FD) {
            auto Type = FD->getType();
+           if (Type->isArrayType())
+             Type = Type->getBaseElementTypeUnsafe()->getCanonicalTypeUnqualified();
+
            if (Type->isReferenceType() || Type->isEnumeralType())
              return false;
            if (const auto *RD = Type->getAsCXXRecordDecl())
              return HasNonDeletedDefaultedEqualityComparison(RD);
            return true;
          });
 }
 

clang/test/SemaCXX/type-traits.cpp

 
 struct TriviallyEqualityComparableContainsArray {
   int a[4];
 
   bool operator==(const TriviallyEqualityComparableContainsArray&) const = default;
 };
 static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparableContainsArray));
 
+struct TriviallyEqualityComparableContainsMultiDimensionArray {
+  int a[4][4];
+
+  bool operator==(const TriviallyEqualityComparableContainsMultiDimensionArray&) const = default;
+};
+static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparableContainsMultiDimensionArray));
+
 struct TriviallyEqualityComparableNonTriviallyCopyable {
   TriviallyEqualityComparableNonTriviallyCopyable(const TriviallyEqualityComparableNonTriviallyCopyable&);
   ~TriviallyEqualityComparableNonTriviallyCopyable();
   bool operator==(const TriviallyEqualityComparableNonTriviallyCopyable&) const = default;
   int i;
 };
 static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparableNonTriviallyCopyable));
 

 static_assert(!__is_trivially_equality_comparable(E));
 
 struct NotTriviallyEqualityComparableHasEnum {
   E e;
   bool operator==(const NotTriviallyEqualityComparableHasEnum&) const = default;
 };
 static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasEnum));
 
+struct NotTriviallyEqualityComparableNonTriviallyEqualityComparableArrs {
+  E e[1];
+
+  bool operator==(const NotTriviallyEqualityComparableNonTriviallyEqualityComparableArrs&) const = default;
+};
+static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableNonTriviallyEqualityComparableArrs));
+
+struct NotTriviallyEqualityComparableNonTriviallyEqualityComparableArrs2 {
+  E e[1][1];
+
+  bool operator==(const NotTriviallyEqualityComparableNonTriviallyEqualityComparableArrs2&) const = default;
+};
+static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableNonTriviallyEqualityComparableArrs2));
+
 namespace hidden_friend {
 
 struct TriviallyEqualityComparable {
   int i;
   int j;
 
   void func();
   bool operator==(int) const { return false; }