[clang] c5f954a - Revert "[clang][Sema] Recheck array size once the element type is complete" (#239935)

via cfe-commits cfe-commits at lists.llvm.org
Sat Nov 7 01:28:42 PST 2026


Author: Nikita Popov
Date: 2026-11-07T09:28:36Z
New Revision: c5f954af1066a98bc39f5f8f3f1be4cfd8cafd63

URL: https://github.com/llvm/llvm-project/commit/c5f954af1066a98bc39f5f8f3f1be4cfd8cafd63
DIFF: https://github.com/llvm/llvm-project/commit/c5f954af1066a98bc39f5f8f3f1be4cfd8cafd63.diff

LOG: Revert "[clang][Sema] Recheck array size once the element type is complete" (#239935)

Reverts llvm/llvm-project#219817

Causes a large compile-time regression.

Added: 
    

Modified: 
    clang/docs/ReleaseNotes.md
    clang/include/clang/Basic/DiagnosticSemaKinds.td
    clang/include/clang/Sema/Sema.h
    clang/lib/Sema/SemaDecl.cpp
    clang/lib/Sema/SemaType.cpp

Removed: 
    clang/test/SemaCXX/array-size.cpp


################################################################################
diff  --git a/clang/docs/ReleaseNotes.md b/clang/docs/ReleaseNotes.md
index b2ce1c1cc9b6c..9219384616cb7 100644
--- a/clang/docs/ReleaseNotes.md
+++ b/clang/docs/ReleaseNotes.md
@@ -1049,12 +1049,6 @@ documentation](CIR/index.md) for more information regarding ClangIR's status and
   by a using-declaration (e.g. `using Base::operator auto;`). Such a conversion
   function is now also diagnosed if it is deleted. (#GH189146)
 
-- Fixed an assertion failure when an array whose element type was still
-  incomplete when the array type was formed (for example, an array of a class
-  template specialization that is only instantiated later) turned out to be too
-  large once the element type was completed. Clang now diagnoses the oversized
-  array instead of asserting. (#GH213855)
-
 - A workaround that was introduced to fix an issue with the `<format>` header present in some versions of
   libstdc++15 has been extended to support preprocessed input. Previously, splitting the preprocessing and
   compilation step would result in the fix not being applied. (#GH160314)

diff  --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
index 60e4c639be722..80de4627959c4 100644
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -6758,8 +6758,6 @@ def err_vm_func_decl : Error<
   "function declaration cannot have variably modified type">;
 def err_array_too_large : Error<
   "array is too large (%0 elements)">;
-def err_array_size_too_large : Error<
-  "array is too large (%0 bytes)">;
 
 def err_type_too_large_for_address_space : Error<
   "%0 is too large for the address space (maximum allowed size of %1 bytes)">;

diff  --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index 34b8a74d1a0df..3abbaf6b1941e 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -15797,8 +15797,7 @@ class Sema final : public SemaBase {
   /// this routine then attempts to perform class template
   /// instantiation. If instantiation fails, or if @p T is incomplete
   /// and cannot be completed, issues the diagnostic @p diag (giving it
-  /// the type @p T) and returns true. The same applies to an array type
-  /// that turns out to be too large once its element type is complete.
+  /// the type @p T) and returns true.
   ///
   /// @param Loc  The location in the source that the incomplete type
   /// diagnostic should refer to.

diff  --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp
index b30880ce6651f..d4fbf04ee284a 100644
--- a/clang/lib/Sema/SemaDecl.cpp
+++ b/clang/lib/Sema/SemaDecl.cpp
@@ -14925,13 +14925,6 @@ void Sema::ActOnUninitializedDecl(Decl *RealDecl) {
         Var->setInvalidDecl();
         return;
       }
-      // Completing the element type may reveal that the array is too large.
-      if (Type->isConstantArrayType() &&
-          RequireCompleteType(Var->getLocation(), Type,
-                              diag::err_typecheck_decl_incomplete_type)) {
-        Var->setInvalidDecl();
-        return;
-      }
     } else {
       return;
     }

diff  --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp
index 81fd8d34e0eb8..e16630ce9cd84 100644
--- a/clang/lib/Sema/SemaType.cpp
+++ b/clang/lib/Sema/SemaType.cpp
@@ -9753,35 +9753,6 @@ static void assignInheritanceModel(Sema &S, CXXRecordDecl *RD) {
   }
 }
 
-/// If \p T is (or contains) a constant array type whose size in bytes cannot
-/// be represented within ConstantArrayType::getMaxSizeBits, return the
-/// offending array type. Nested arrays are checked from the inside out, since
-/// the size of an outer array can only be computed once its element's size is
-/// known to fit. BuildArrayType can only check the element count if the
-/// element type is still incomplete when the array type is formed, so the
-/// size has to be rechecked once the element type is completed.
-static const ConstantArrayType *
-getOversizedConstantArray(const ASTContext &Context, QualType T) {
-  if (T->isDependentType() || T->isVariablyModifiedType() ||
-      T->isUndeducedType())
-    return nullptr;
-
-  const ConstantArrayType *CAT = Context.getAsConstantArrayType(T);
-  if (!CAT)
-    return nullptr;
-
-  QualType ElementType = CAT->getElementType();
-  if (const ConstantArrayType *Inner =
-          getOversizedConstantArray(Context, ElementType))
-    return Inner;
-
-  if (ConstantArrayType::getNumAddressingBits(Context, ElementType,
-                                              CAT->getSize()) >
-      ConstantArrayType::getMaxSizeBits(Context))
-    return CAT;
-  return nullptr;
-}
-
 bool Sema::RequireCompleteTypeImpl(SourceLocation Loc, QualType T,
                                    CompleteTypeKind Kind,
                                    TypeDiagnoser *Diagnoser) {
@@ -9833,19 +9804,6 @@ bool Sema::RequireCompleteTypeImpl(SourceLocation Loc, QualType T,
                               /*Recover*/ TreatAsComplete);
       return !TreatAsComplete;
     }
-
-    // The element type may have been incomplete when the array type was
-    // formed, in which case BuildArrayType could not check the array's size.
-    if (const ConstantArrayType *CAT = getOversizedConstantArray(Context, T)) {
-      if (Diagnoser) {
-        CharUnits ElementSize =
-            Context.getTypeSizeInChars(CAT->getElementType());
-        llvm::APInt SizeInBytes = CAT->getSize().zext(128) *
-                                  llvm::APInt(128, ElementSize.getQuantity());
-        Diag(Loc, diag::err_array_size_too_large) << SizeInBytes;
-      }
-      return true;
-    }
     return false;
   }
 

diff  --git a/clang/test/SemaCXX/array-size.cpp b/clang/test/SemaCXX/array-size.cpp
deleted file mode 100644
index 02ec4af7d4b07..0000000000000
--- a/clang/test/SemaCXX/array-size.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-// RUN: %clang_cc1 -fsyntax-only -verify -triple x86_64-linux-gnu %s
-
-// An array whose element type is incomplete when the array type is formed can
-// only have its size checked once the element type is completed (#GH213855).
-
-namespace GH213855 {
-template <unsigned Size> struct S : public CBdVfsImpl { // expected-error {{expected class name}}
-  double A[Size];
-};
-template <unsigned Size> struct SS {
-  S<Size> A[Size]; // expected-error {{array is too large (147'573'944'137'180'895'432 bytes)}}
-void foo() { SS<-123> ss; } // expected-error {{non-type template argument evaluates to -123, which cannot be narrowed to type 'unsigned int'}} \
-                            // expected-note {{in instantiation of template class 'GH213855::SS<4294967173>' requested here}}
-};
-} // namespace GH213855
-
-namespace array_variable {
-template <unsigned Size> struct S { double A[Size]; };
-S<4294967173u> arr[4294967173u]; // expected-error {{array is too large (147'573'944'137'180'895'432 bytes)}}
-} // namespace array_variable
-
-namespace dependent_context {
-template <unsigned Size> struct S { double A[Size]; };
-
-// Diagnosed once, at the template definition, not once per instantiation.
-template <typename T> struct Parent {
-  S<4294967173u> A[4294967173u]; // expected-error {{array is too large (147'573'944'137'180'895'432 bytes)}}
-};
-Parent<int> p1;
-Parent<long> p2;
-
-template <typename T> struct Parent2 {
-  double A[2305843009213693952u]; // expected-error {{array is too large (2'305'843'009'213'693'952 elements)}}
-};
-Parent2<int> p3;
-Parent2<long> p4;
-
-template <typename T> struct ParentOK {
-  double A[4294967173u]; // ~2^35 bytes, still representable.
-};
-ParentOK<int> ok;
-} // namespace dependent_context
-
-namespace incomplete_element_type {
-struct Incomplete;
-extern Incomplete ok[2];
-extern Incomplete arr[4294967173];
-extern Incomplete arr2[2][4294967173];
-struct Incomplete { double A[4294967173]; };
-Incomplete arr3[4294967173]; // expected-error {{array is too large (4'294'967'173 elements)}}
-
-unsigned long n0 = sizeof(ok);
-unsigned long n1 = sizeof(arr); // expected-error {{array is too large (147'573'944'137'180'895'432 bytes)}}
-unsigned long n2 = sizeof(arr2); // expected-error {{array is too large (147'573'944'137'180'895'432 bytes)}}
-} // namespace incomplete_element_type


        


More information about the cfe-commits mailing list