https://github.com/usx95 created https://github.com/llvm/llvm-project/pull/172146
None >From 7fd349ed4dcd1a20320035fe52d79e2194ad852e Mon Sep 17 00:00:00 2001 From: Utkarsh Saxena <[email protected]> Date: Sat, 13 Dec 2025 09:42:36 +0000 Subject: [PATCH] merge-attr-implicit-this --- .../LifetimeSafety/LifetimeAnnotations.cpp | 5 ++ clang/lib/Sema/SemaDecl.cpp | 63 +++++++++++++++++-- clang/test/SemaCXX/attr-lifetimebound.cpp | 12 ++++ 3 files changed, 74 insertions(+), 6 deletions(-) diff --git a/clang/lib/Analysis/LifetimeSafety/LifetimeAnnotations.cpp b/clang/lib/Analysis/LifetimeSafety/LifetimeAnnotations.cpp index 54e343fc2ee5e..84ed1b8fd86c6 100644 --- a/clang/lib/Analysis/LifetimeSafety/LifetimeAnnotations.cpp +++ b/clang/lib/Analysis/LifetimeSafety/LifetimeAnnotations.cpp @@ -54,6 +54,11 @@ bool isAssignmentOperatorLifetimeBound(const CXXMethodDecl *CMD) { bool implicitObjectParamIsLifetimeBound(const FunctionDecl *FD) { FD = getDeclWithMergedLifetimeBoundAttrs(FD); + + // if (const auto *RD = FD->getPreviousDecl(); RD && RD != FD) + // if (implicitObjectParamIsLifetimeBound(RD)) + // return true; + const TypeSourceInfo *TSI = FD->getTypeSourceInfo(); if (!TSI) return false; diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp index 47bd7295e93f6..3dd62c1428271 100644 --- a/clang/lib/Sema/SemaDecl.cpp +++ b/clang/lib/Sema/SemaDecl.cpp @@ -4469,6 +4469,52 @@ bool Sema::MergeFunctionDecl(FunctionDecl *New, NamedDecl *&OldD, Scope *S, return true; } +/// Check if a function has a lifetimebound attribute on its function type +/// (which represents the implicit 'this' parameter for methods). +/// Returns the attribute if found, nullptr otherwise. +static const LifetimeBoundAttr * +getLifetimeBoundAttrFromType(const TypeSourceInfo *TSI) { + if (!TSI) + return nullptr; + + for (TypeLoc TL = TSI->getTypeLoc();;) { + auto ATL = TL.getAsAdjusted<AttributedTypeLoc>(); + if (!ATL) + break; + if (auto *LBAttr = ATL.getAttrAs<LifetimeBoundAttr>()) + return LBAttr; + TL = ATL.getModifiedLoc(); + } + return nullptr; +} + +/// Merge lifetimebound attribute on function type (implicit 'this') +/// from Old to New method declaration. +static void mergeLifetimeBoundAttrOnMethod(Sema &S, CXXMethodDecl *New, + const CXXMethodDecl *Old) { + const TypeSourceInfo *OldTSI = Old->getTypeSourceInfo(); + const TypeSourceInfo *NewTSI = New->getTypeSourceInfo(); + + if (!OldTSI || !NewTSI) + return; + + const LifetimeBoundAttr *OldLBAttr = getLifetimeBoundAttrFromType(OldTSI); + const LifetimeBoundAttr *NewLBAttr = getLifetimeBoundAttrFromType(NewTSI); + + // If Old has lifetimebound but New doesn't, add it to New + if (OldLBAttr && !NewLBAttr) { + QualType NewMethodType = New->getType(); + QualType AttributedType = + S.Context.getAttributedType(OldLBAttr, NewMethodType, NewMethodType); + TypeLocBuilder TLB; + TLB.pushFullCopy(NewTSI->getTypeLoc()); + AttributedTypeLoc TyLoc = TLB.push<AttributedTypeLoc>(AttributedType); + TyLoc.setAttr(OldLBAttr); + New->setType(AttributedType); + New->setTypeSourceInfo(TLB.getTypeSourceInfo(S.Context, AttributedType)); + } +} + bool Sema::MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old, Scope *S, bool MergeTypeWithOld) { // Merge the attributes @@ -4485,12 +4531,17 @@ bool Sema::MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old, // Merge attributes from the parameters. These can mismatch with K&R // declarations. if (New->getNumParams() == Old->getNumParams()) - for (unsigned i = 0, e = New->getNumParams(); i != e; ++i) { - ParmVarDecl *NewParam = New->getParamDecl(i); - ParmVarDecl *OldParam = Old->getParamDecl(i); - mergeParamDeclAttributes(NewParam, OldParam, *this); - mergeParamDeclTypes(NewParam, OldParam, *this); - } + for (unsigned i = 0, e = New->getNumParams(); i != e; ++i) { + ParmVarDecl *NewParam = New->getParamDecl(i); + ParmVarDecl *OldParam = Old->getParamDecl(i); + mergeParamDeclAttributes(NewParam, OldParam, *this); + mergeParamDeclTypes(NewParam, OldParam, *this); + } + + // Merge function type attributes (e.g., lifetimebound on implicit 'this'). + if (auto *NewMethod = dyn_cast<CXXMethodDecl>(New)) + if (auto *OldMethod = dyn_cast<CXXMethodDecl>(Old)) + mergeLifetimeBoundAttrOnMethod(*this, NewMethod, OldMethod); if (getLangOpts().CPlusPlus) return MergeCXXFunctionDecl(New, Old, S); diff --git a/clang/test/SemaCXX/attr-lifetimebound.cpp b/clang/test/SemaCXX/attr-lifetimebound.cpp index 111bad65f7e1b..5b0aa0e518cb3 100644 --- a/clang/test/SemaCXX/attr-lifetimebound.cpp +++ b/clang/test/SemaCXX/attr-lifetimebound.cpp @@ -75,6 +75,18 @@ namespace usage_ok { r = A(1); // expected-warning {{object backing the pointer 'r' will be destroyed at the end of the full-expression}} } + // Test that lifetimebound on implicit 'this' is propagated across redeclarations + struct B { + int *method() [[clang::lifetimebound]]; + int i; + }; + int *B::method() { return &i; } + + void test_lifetimebound_on_implicit_this() { + int *t = B().method(); // expected-warning {{temporary whose address is used as value of local variable 't' will be destroyed at the end of the full-expression}} + t = {B().method()}; // expected-warning {{object backing the pointer 't' will be destroyed at the end of the full-expression}} + } + struct FieldCheck { struct Set { int a; _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
