[clang] [clang] Diagnose VLA types from an enclosing function in local classes and blocks (PR #229697)
Eli Friedman via cfe-commits
cfe-commits at lists.llvm.org
Tue Nov 10 16:47:35 PST 2026
================
@@ -4782,6 +4777,107 @@ static void captureVariablyModifiedType(ASTContext &Context, QualType T,
} while (!T.isNull() && T->isVariablyModifiedType());
}
+static void captureVariablyModifiedType(ASTContext &Context, QualType T,
+ CapturingScopeInfo *CSI) {
+ assert(CSI != nullptr);
+ forEachVariableArrayType(Context, T, [&](const VariableArrayType *VAT) {
+ // Unknown size indication requires no size computation.
+ // Otherwise, evaluate and record it.
+ auto Size = VAT->getSizeExpr();
+ if (Size && !CSI->isVLATypeCaptured(VAT) &&
+ (isa<CapturedRegionScopeInfo>(CSI) || isa<LambdaScopeInfo>(CSI)))
+ CSI->addVLATypeCapture(Size->getExprLoc(), VAT, Context.getSizeType());
+ });
+}
+
+/// Find the capturing scope that is being built for the lambda call operator
+/// or captured declaration \p DC, if any.
+static CapturingScopeInfo *
+findCapturingScope(ArrayRef<FunctionScopeInfo *> Scopes,
+ const DeclContext *DC) {
+ for (FunctionScopeInfo *FSI : llvm::reverse(Scopes)) {
+ if (auto *LSI = dyn_cast<LambdaScopeInfo>(FSI);
+ LSI && LSI->CallOperator == DC)
+ return LSI;
+ if (auto *CRSI = dyn_cast<CapturedRegionScopeInfo>(FSI);
+ CRSI && CRSI->TheCapturedDecl == DC)
+ return CRSI;
+ }
+ return nullptr;
+}
+
+bool Sema::CheckVariablyModifiedTypeUse(QualType T, SourceLocation Loc) {
+ if (VLASizeExprOwners.empty() || T.isNull())
+ return true;
+ // Deduced types (auto, __auto_type) do not propagate the variably modified
+ // bit, so look at the canonical type.
+ QualType CanonT = T.getCanonicalType();
+ if (!CanonT->isVariablyModifiedType())
+ return true;
+
+ const Expr *BadSize = nullptr;
+ unsigned BadKind = 0;
+ forEachVariableArrayType(Context, CanonT, [&](const VariableArrayType *VAT) {
+ const Expr *Size = VAT->getSizeExpr();
+ if (BadSize || !Size)
+ return;
+ auto It = VLASizeExprOwners.find(Size);
+ if (It == VLASizeExprOwners.end())
+ return;
+
+ // Walk from the use to the context in which the bound is evaluated.
+ // Lambdas and captured regions on the way capture the bound; a local
+ // class or a block cannot see it.
+ SmallVector<CapturingScopeInfo *, 2> Capturers;
+ std::optional<unsigned> Barrier;
+ const DeclContext *DC = CurContext;
+ for (; DC && DC != It->second; DC = DC->getParent()) {
+ if (isLambdaCallOperator(DC) || isa<CapturedDecl>(DC)) {
+ if (CapturingScopeInfo *CSI = findCapturingScope(FunctionScopes, DC))
+ Capturers.push_back(CSI);
+ } else if (isa<BlockDecl>(DC)) {
+ Barrier = Barrier.value_or(1);
+ } else if (const auto *RD = dyn_cast<RecordDecl>(DC)) {
+ if (const auto *CRD = dyn_cast<CXXRecordDecl>(RD);
+ !CRD || !CRD->isLambda())
+ Barrier = Barrier.value_or(0);
+ }
+ }
+ // Nothing to do if the bound is not evaluated in an enclosing context.
+ if (!DC)
+ return;
+ if (Barrier) {
+ BadSize = Size;
+ BadKind = *Barrier;
+ return;
+ }
+ // VAT is a canonical type; the bound may already have been captured
+ // through a different type node with the same size expression.
+ for (CapturingScopeInfo *CSI : Capturers)
+ if (llvm::none_of(CSI->Captures, [&](const Capture &C) {
+ return C.isVLATypeCapture() &&
+ C.getCapturedVLAType()->getSizeExpr() == Size;
+ }))
+ CSI->addVLATypeCapture(Size->getExprLoc(), VAT, Context.getSizeType());
+ });
+ if (!BadSize)
+ return true;
+
+ // Default arguments and default member initializers are evaluated where
+ // they are used, and unevaluated operands are not evaluated at all.
+ if (isUnevaluatedContext() || isCheckingDefaultArgumentOrInitializer())
----------------
efriedma-quic wrote:
Consider moving these checks earlier? They should be cheap.
https://github.com/llvm/llvm-project/pull/229697
More information about the cfe-commits
mailing list