[clang] e1eeaaa - [LifetimeSafety] Map arguments to an explicit object parameter correctly (#240411)
via cfe-commits
cfe-commits at lists.llvm.org
Tue Nov 10 07:47:26 PST 2026
Author: Gábor Horváth
Date: 2026-11-10T15:47:20Z
New Revision: e1eeaaae8f11ec193414f20842c28c74e1240bbc
URL: https://github.com/llvm/llvm-project/commit/e1eeaaae8f11ec193414f20842c28c74e1240bbc
DIFF: https://github.com/llvm/llvm-project/commit/e1eeaaae8f11ec193414f20842c28c74e1240bbc.diff
LOG: [LifetimeSafety] Map arguments to an explicit object parameter correctly (#240411)
For a C++23 explicit object member function the object argument binds to
`self`, getParamDecl(0), but getTrackedArgInfo mapped argument I to
getParamDecl(I - 1) as for an implicit object. A lifetimebound parameter
after `self` was ignored, lifetimebound on `self` was attributed to the
next argument, and a by-value `self` of a gsl::Pointer hit an assertion.
Add hasObjectArg, hasImplicitObjectArg and getParamForArg, and use them
wherever call arguments are mapped to parameters.
Assisted-by: Claude Opus 5.5
Co-authored-by: Gabor Horvath <gaborh at apple.com>
Added:
clang/test/Sema/LifetimeSafety/explicit-object-param.cpp
Modified:
clang/include/clang/Analysis/Analyses/LifetimeSafety/LifetimeAnnotations.h
clang/lib/Analysis/LifetimeSafety/FactsGenerator.cpp
clang/lib/Analysis/LifetimeSafety/LifetimeAnnotations.cpp
Removed:
clang/test/Sema/LifetimeSafety/explicit-object-param-no-crash.cpp
################################################################################
diff --git a/clang/include/clang/Analysis/Analyses/LifetimeSafety/LifetimeAnnotations.h b/clang/include/clang/Analysis/Analyses/LifetimeSafety/LifetimeAnnotations.h
index 6f9255311d9496..200c69dafa9699 100644
--- a/clang/include/clang/Analysis/Analyses/LifetimeSafety/LifetimeAnnotations.h
+++ b/clang/include/clang/Analysis/Analyses/LifetimeSafety/LifetimeAnnotations.h
@@ -81,6 +81,20 @@ struct FunctionCallInfo {
explicit FunctionCallInfo(const Expr *Call);
};
+/// Returns true if argument 0 of a call to \p FD (as listed by
+/// FunctionCallInfo) is the object argument, bound either to the implicit
+/// object parameter or to an explicit object parameter. Constructors have no
+/// object argument.
+bool hasObjectArg(const FunctionDecl &FD);
+
+/// Returns true if argument 0 of a call to \p FD is the implicit object
+/// argument. An explicit object parameter is an ordinary parameter.
+bool hasImplicitObjectArg(const FunctionDecl &FD);
+
+/// Returns the parameter that argument \p I of a call to \p FD binds to, or
+/// null for the implicit object argument and for variadic arguments.
+const ParmVarDecl *getParamForArg(const FunctionDecl &FD, unsigned I);
+
/// Returns the parameter corresponding to argument I when the argument should
/// be tracked for lifetime safety.
std::optional<LifetimeBoundParamInfo>
diff --git a/clang/lib/Analysis/LifetimeSafety/FactsGenerator.cpp b/clang/lib/Analysis/LifetimeSafety/FactsGenerator.cpp
index 7356c6b5ce134c..fd2709edd88bb0 100644
--- a/clang/lib/Analysis/LifetimeSafety/FactsGenerator.cpp
+++ b/clang/lib/Analysis/LifetimeSafety/FactsGenerator.cpp
@@ -965,30 +965,23 @@ void FactsGenerator::handleGSLPointerConstruction(const CXXConstructExpr *CCE) {
void FactsGenerator::handleMovedArgsInCall(const FunctionDecl *FD,
ArrayRef<const Expr *> Args) {
- unsigned ImplicitObjectArgOffset = 0;
- // Constructors are excluded because Args has no object argument for them,
- // even though isImplicitObjectMemberFunction() is true.
+ // std::unique_ptr::release() transfers ownership.
+ // Treat it as a move to prevent false-positive warnings when the unique_ptr
+ // destructor runs after ownership has been transferred.
if (const auto *MD = dyn_cast<CXXMethodDecl>(FD);
- MD && !isa<CXXConstructorDecl>(FD) &&
- MD->isImplicitObjectMemberFunction()) {
- ImplicitObjectArgOffset = 1;
- // std::unique_ptr::release() transfers ownership.
- // Treat it as a move to prevent false-positive warnings when the unique_ptr
- // destructor runs after ownership has been transferred.
- if (isUniquePtrRelease(*MD)) {
- const Expr *UniquePtrExpr = Args[0];
- OriginList *MovedOrigins = getOriginsList(*UniquePtrExpr);
- if (MovedOrigins)
- CurrentBlockFacts.push_back(FactMgr.createFact<MovedOriginFact>(
- UniquePtrExpr, MovedOrigins->getOuterOriginID()));
- }
+ MD && hasImplicitObjectArg(*FD) && isUniquePtrRelease(*MD)) {
+ const Expr *UniquePtrExpr = Args[0];
+ OriginList *MovedOrigins = getOriginsList(*UniquePtrExpr);
+ if (MovedOrigins)
+ CurrentBlockFacts.push_back(FactMgr.createFact<MovedOriginFact>(
+ UniquePtrExpr, MovedOrigins->getOuterOriginID()));
}
- // Skip implicit 'this' arg as it cannot be moved.
- for (unsigned I = ImplicitObjectArgOffset;
- I < Args.size() && I < FD->getNumParams() + ImplicitObjectArgOffset;
- ++I) {
- const ParmVarDecl *PVD = FD->getParamDecl(I - ImplicitObjectArgOffset);
+ for (unsigned I = 0; I < Args.size(); ++I) {
+ // Null for the implicit 'this' arg, which cannot be moved.
+ const ParmVarDecl *PVD = getParamForArg(*FD, I);
+ if (!PVD)
+ continue;
// In principle, explicit object parameters can be moved, but skip marking
// them as moved for consistency with implicit 'this'.
if (PVD->isExplicitObjectParameter())
@@ -1085,31 +1078,13 @@ void FactsGenerator::handleLifetimeCaptureBy(const FunctionDecl *FD,
// FIXME: Add support for capture_by on constructors.
if (isa<CXXConstructorDecl>(FD))
return;
- const auto *Method = dyn_cast<CXXMethodDecl>(FD);
- bool HasImplicitObjectArg = Method &&
- Method->isImplicitObjectMemberFunction() &&
- !isa<CXXConstructorDecl>(FD);
auto getArgCaptureByAttr =
- [FD, HasImplicitObjectArg](
- unsigned I) -> std::pair<const LifetimeCaptureByAttr *, QualType> {
- if (HasImplicitObjectArg) {
- if (I == 0) {
- auto *MethodDecl = cast<CXXMethodDecl>(FD);
- QualType ParamType = MethodDecl->getFunctionObjectParameterType();
- return {getCaptureByAttrFromFunctionType(FD), ParamType};
- }
- if (I > 0 && I - 1 < FD->getNumParams()) {
- const ParmVarDecl *PVD = FD->getParamDecl(I - 1);
- return {PVD ? PVD->getAttr<LifetimeCaptureByAttr>() : nullptr,
- PVD->getType()};
- }
- } else {
- if (I < FD->getNumParams()) {
- const ParmVarDecl *PVD = FD->getParamDecl(I);
- return {PVD ? PVD->getAttr<LifetimeCaptureByAttr>() : nullptr,
- PVD->getType()};
- }
- }
+ [FD](unsigned I) -> std::pair<const LifetimeCaptureByAttr *, QualType> {
+ if (I == 0 && hasImplicitObjectArg(*FD))
+ return {getCaptureByAttrFromFunctionType(FD),
+ cast<CXXMethodDecl>(FD)->getFunctionObjectParameterType()};
+ if (const ParmVarDecl *PVD = getParamForArg(*FD, I))
+ return {PVD->getAttr<LifetimeCaptureByAttr>(), PVD->getType()};
return {nullptr, QualType()};
};
for (unsigned I = 0; I < Args.size(); ++I) {
@@ -1234,11 +1209,14 @@ void FactsGenerator::handleFunctionCall(const Expr *Call,
return;
}
auto shouldTrackPointerImplicitObjectArg = [FD, &Args](unsigned I) -> bool {
- const auto *Method = dyn_cast<CXXMethodDecl>(FD);
- if (!Method || !Method->isInstance())
+ if (I != 0 || !hasObjectArg(*FD))
+ return false;
+ // A by-value explicit object parameter takes a prvalue copy, which is
+ // handled as an ordinary argument below.
+ if (!hasImplicitObjectArg(*FD) && !Args[0]->isGLValue())
return false;
- return I == 0 &&
- isGslPointerType(Method->getFunctionObjectParameterType()) &&
+ const auto *Method = cast<CXXMethodDecl>(FD);
+ return isGslPointerType(Method->getFunctionObjectParameterType()) &&
shouldTrackImplicitObjectArg(*Args[0], Method,
/*RunningUnderLifetimeSafety=*/true);
};
diff --git a/clang/lib/Analysis/LifetimeSafety/LifetimeAnnotations.cpp b/clang/lib/Analysis/LifetimeSafety/LifetimeAnnotations.cpp
index dd00ff4f5ccb61..310e55931fc448 100644
--- a/clang/lib/Analysis/LifetimeSafety/LifetimeAnnotations.cpp
+++ b/clang/lib/Analysis/LifetimeSafety/LifetimeAnnotations.cpp
@@ -132,6 +132,25 @@ FunctionCallInfo::FunctionCallInfo(const Expr *Call) {
FD = dyn_cast_or_null<FunctionDecl>(AC->getDecl());
}
+bool hasObjectArg(const FunctionDecl &FD) {
+ const auto *MD = dyn_cast<CXXMethodDecl>(&FD);
+ return MD && MD->isInstance() && !isa<CXXConstructorDecl>(MD);
+}
+
+bool hasImplicitObjectArg(const FunctionDecl &FD) {
+ return hasObjectArg(FD) &&
+ cast<CXXMethodDecl>(FD).isImplicitObjectMemberFunction();
+}
+
+const ParmVarDecl *getParamForArg(const FunctionDecl &FD, unsigned I) {
+ if (hasImplicitObjectArg(FD)) {
+ if (I == 0)
+ return nullptr;
+ --I;
+ }
+ return I < FD.getNumParams() ? FD.getParamDecl(I) : nullptr;
+}
+
std::optional<LifetimeBoundParamInfo>
getTrackedArgInfo(const FunctionDecl *FD, llvm::ArrayRef<const Expr *> Args,
unsigned I) {
@@ -139,31 +158,28 @@ getTrackedArgInfo(const FunctionDecl *FD, llvm::ArrayRef<const Expr *> Args,
if (!FD || I >= Args.size())
return std::nullopt;
- const ParmVarDecl *PVD = nullptr;
-
- if (const auto *Method = dyn_cast<CXXMethodDecl>(FD);
- Method && Method->isInstance() && !isa<CXXConstructorDecl>(FD)) {
- if (I == 0) {
- // For the 'this' argument, the attribute is on the method itself.
- if (implicitObjectParamIsLifetimeBound(Method) ||
- shouldTrackImplicitObjectArg(*Args[0], Method,
- /*RunningUnderLifetimeSafety=*/true))
- return LifetimeBoundParamInfo(Method);
- return std::nullopt;
- }
- if ((I - 1) < Method->getNumParams())
- // For explicit arguments, find the corresponding parameter declaration.
- PVD = Method->getParamDecl(I - 1);
- } else if (I == 0 && shouldTrackFirstArgument(FD)) {
- return LifetimeBoundParamInfo(FD->getParamDecl(I));
- } else if (I == 1 && shouldTrackSecondArgument(FD)) {
- return LifetimeBoundParamInfo(FD->getParamDecl(I));
- } else if (I < FD->getNumParams()) {
- // For free functions or static methods.
- PVD = FD->getParamDecl(I);
+ if (I == 0 && hasObjectArg(*FD)) {
+ const auto *Method = cast<CXXMethodDecl>(FD);
+ bool TrackObject =
+ implicitObjectParamIsLifetimeBound(Method) ||
+ shouldTrackImplicitObjectArg(*Args[0], Method,
+ /*RunningUnderLifetimeSafety=*/true);
+ if (hasImplicitObjectArg(*FD))
+ return TrackObject ? std::optional(LifetimeBoundParamInfo(Method))
+ : std::nullopt;
+ // An explicit object parameter is reported as the parameter it is.
+ if (TrackObject)
+ return LifetimeBoundParamInfo(Method->getParamDecl(0));
+ }
+ if (!hasImplicitObjectArg(*FD)) {
+ if (I == 0 && shouldTrackFirstArgument(FD))
+ return LifetimeBoundParamInfo(FD->getParamDecl(I));
+ if (I == 1 && shouldTrackSecondArgument(FD))
+ return LifetimeBoundParamInfo(FD->getParamDecl(I));
}
- if (PVD && PVD->hasAttr<clang::LifetimeBoundAttr>())
+ if (const ParmVarDecl *PVD = getParamForArg(*FD, I);
+ PVD && PVD->hasAttr<clang::LifetimeBoundAttr>())
return LifetimeBoundParamInfo(PVD);
return std::nullopt;
diff --git a/clang/test/Sema/LifetimeSafety/explicit-object-param-no-crash.cpp b/clang/test/Sema/LifetimeSafety/explicit-object-param-no-crash.cpp
deleted file mode 100644
index 31c07d9d7f1028..00000000000000
--- a/clang/test/Sema/LifetimeSafety/explicit-object-param-no-crash.cpp
+++ /dev/null
@@ -1,106 +0,0 @@
-// RUN: %clang_cc1 %s -std=c++23 -verify -fsyntax-only -Wlifetime-safety -Wlifetime-safety-lifetimebound-violation
-
-#include "Inputs/lifetime-analysis.h"
-
-// Explicit object member functions must not be treated as having an implicit
-// object argument.
-struct Foo {
- template <typename T>
- int get(this Foo &&self, T) {
- return self.field;
- }
-
- int field;
-};
-
-struct Base {};
-struct Derived : Base {
- int base(this Base &&, int);
-};
-
-template <typename T>
-struct Crtp {
- template <typename Self>
- int deduced(this Self &&self, T) {
- return self.field;
- }
-};
-
-struct Widget : Crtp<int> {
- int field;
-};
-
-struct NoMove {
- NoMove() = default;
- NoMove(NoMove &&) = delete;
- NoMove(const NoMove &) = delete;
-
- int get(this NoMove &&self, int) {
- return self.field;
- }
-
- int field;
-};
-
-template <typename T>
-struct SharedPtr {
- SharedPtr() = default;
- SharedPtr(SharedPtr &&o) : p(o.p) { o.p = nullptr; }
- SharedPtr(const SharedPtr &) = default;
-
- int get(this SharedPtr &&self, int) {
- return self.p->field;
- }
-
- T *p = nullptr;
-};
-
-void call() {
- Foo().get(0);
- Derived().base(0);
- Widget().deduced(0);
- NoMove().get(0);
- SharedPtr<NoMove>().get(0);
-}
-
-struct Holder {
- int field;
- const int *borrow() [[clang::lifetimebound]] { return &field; }
- void consume(this Holder &&self) {}
-};
-
-const int *object_arg_is_not_moved(Holder &&h [[clang::lifetimebound]]) {
- static_cast<Holder &&>(h).consume();
- return h.borrow();
-}
-
-const int *t1(Holder h) {
- const int *ptr = h.borrow(); // expected-warning {{stack memory associated with parameter 'h' is returned}} \
- // expected-note {{result of call to 'borrow' aliases the storage of parameter 'h' because the implicit object parameter is marked as lifetimebound}}
- static_cast<Holder &&>(h).consume();
- return ptr; // expected-note {{returned here}}
-}
-
-const int *t2(Holder h) {
- const int *ptr = h.borrow(); // expected-warning {{stack memory associated with parameter 'h' is returned}} \
- // expected-note {{result of call to 'borrow' aliases the storage of parameter 'h' because the implicit object parameter is marked as lifetimebound}}
- std::move(h).consume();
- return ptr; // expected-note {{returned here}}
-}
-
-struct Set {
- void insert(this Set &self, const int &x [[clang::lifetime_capture_by(self)]],
- const int &hint);
-};
-
-int global;
-
-void capture_by_explicit_object() {
- Set s;
- {
- int local = 0;
- s.insert(local, global); // expected-warning {{local variable 'local' does not live long enough}}
- s.insert(global, local);
- } // expected-note {{destroyed here}}
- use(s); // expected-note {{later used here}}
-}
diff --git a/clang/test/Sema/LifetimeSafety/explicit-object-param.cpp b/clang/test/Sema/LifetimeSafety/explicit-object-param.cpp
new file mode 100644
index 00000000000000..d708dae3447709
--- /dev/null
+++ b/clang/test/Sema/LifetimeSafety/explicit-object-param.cpp
@@ -0,0 +1,259 @@
+// RUN: %clang_cc1 %s -std=c++23 -verify -fsyntax-only -Wlifetime-safety -Wlifetime-safety-lifetimebound-violation -Wno-dangling
+
+#include "Inputs/lifetime-analysis.h"
+
+// Explicit object member functions must not be treated as having an implicit
+// object argument.
+struct Foo {
+ template <typename T>
+ int get(this Foo &&self, T) {
+ return self.field;
+ }
+
+ int field;
+};
+
+struct Base {};
+struct Derived : Base {
+ int base(this Base &&, int);
+};
+
+template <typename T>
+struct Crtp {
+ template <typename Self>
+ int deduced(this Self &&self, T) {
+ return self.field;
+ }
+};
+
+struct Widget : Crtp<int> {
+ int field;
+};
+
+struct NoMove {
+ NoMove() = default;
+ NoMove(NoMove &&) = delete;
+ NoMove(const NoMove &) = delete;
+
+ int get(this NoMove &&self, int) {
+ return self.field;
+ }
+
+ int field;
+};
+
+template <typename T>
+struct SharedPtr {
+ SharedPtr() = default;
+ SharedPtr(SharedPtr &&o) : p(o.p) { o.p = nullptr; }
+ SharedPtr(const SharedPtr &) = default;
+
+ int get(this SharedPtr &&self, int) {
+ return self.p->field;
+ }
+
+ T *p = nullptr;
+};
+
+void call() {
+ Foo().get(0);
+ Derived().base(0);
+ Widget().deduced(0);
+ NoMove().get(0);
+ SharedPtr<NoMove>().get(0);
+}
+
+struct Holder {
+ int field;
+ const int *borrow() [[clang::lifetimebound]] { return &field; }
+ void consume(this Holder &&self) {}
+};
+
+const int *object_arg_is_not_moved(Holder &&h [[clang::lifetimebound]]) {
+ static_cast<Holder &&>(h).consume();
+ return h.borrow();
+}
+
+const int *t1(Holder h) {
+ const int *ptr = h.borrow(); // expected-warning {{stack memory associated with parameter 'h' is returned}} \
+ // expected-note {{result of call to 'borrow' aliases the storage of parameter 'h' because the implicit object parameter is marked as lifetimebound}}
+ static_cast<Holder &&>(h).consume();
+ return ptr; // expected-note {{returned here}}
+}
+
+const int *t2(Holder h) {
+ const int *ptr = h.borrow(); // expected-warning {{stack memory associated with parameter 'h' is returned}} \
+ // expected-note {{result of call to 'borrow' aliases the storage of parameter 'h' because the implicit object parameter is marked as lifetimebound}}
+ std::move(h).consume();
+ return ptr; // expected-note {{returned here}}
+}
+
+struct Set {
+ void insert(this Set &self, const int &x [[clang::lifetime_capture_by(self)]],
+ const int &hint);
+};
+
+int global;
+
+void capture_by_explicit_object() {
+ Set s;
+ {
+ int local = 0;
+ s.insert(local, global); // expected-warning {{local variable 'local' does not live long enough}}
+ s.insert(global, local);
+ } // expected-note {{destroyed here}}
+ use(s); // expected-note {{later used here}}
+}
+
+struct Lookup {
+ const int &operator[](this const Lookup &self,
+ const int &key [[clang::lifetimebound]]);
+ const int &get(this const Lookup &self,
+ const int &key [[clang::lifetimebound]]);
+ const int &self_bound(this const Lookup &self [[clang::lifetimebound]],
+ const int &key);
+};
+
+const int &lifetimebound_after_explicit_object_subscript(const Lookup &l) {
+ int key = 1;
+ return l[key]; // expected-warning {{stack memory associated with local variable 'key' is returned}} \
+ // expected-note {{returned here}}
+}
+
+const int &lifetimebound_after_explicit_object_call(const Lookup &l) {
+ int key = 1;
+ return l.get(key); // expected-warning {{stack memory associated with local variable 'key' is returned}} \
+ // expected-note {{returned here}}
+}
+
+const int &lifetimebound_explicit_object(const Lookup &l) {
+ int key = 1;
+ return l.self_bound(key);
+}
+
+const int &dangling_explicit_object() {
+ Lookup l;
+ return l.self_bound(1); // expected-warning {{stack memory associated with local variable 'l' is returned}} \
+ // expected-note {{returned here}}
+}
+
+const int &lifetimebound_after_xvalue_explicit_object(Lookup &l) {
+ int key = 1;
+ return std::move(l).get(key); // expected-warning {{stack memory associated with local variable 'key' is returned}} \
+ // expected-note {{returned here}}
+}
+
+const int &lifetimebound_after_prvalue_explicit_object() {
+ int key = 1;
+ return Lookup{}.get(key); // expected-warning {{stack memory associated with local variable 'key' is returned}} \
+ // expected-note {{returned here}}
+}
+
+const int &dangling_xvalue_explicit_object() {
+ Lookup l;
+ return std::move(l).self_bound(1); // expected-warning {{stack memory associated with local variable 'l' is returned}} \
+ // expected-note {{result of call to 'move<Lookup &>' aliases the storage of local variable 'l'}} \
+ // expected-note {{returned here}}
+}
+
+const int &dangling_prvalue_explicit_object() {
+ return Lookup{}.self_bound(1); // expected-warning {{stack memory associated with temporary object is returned}} \
+ // expected-note {{returned here}}
+}
+
+const int &xvalue_explicit_object_param(Lookup &l) {
+ return std::move(l).self_bound(1);
+}
+
+struct Deduced {
+ template <typename Self>
+ const int &get(this Self &&self [[clang::lifetimebound]]);
+ const int &get_auto(this auto &&self [[clang::lifetimebound]]);
+};
+
+const int &dangling_deduced_explicit_object() {
+ Deduced d;
+ return d.get(); // expected-warning {{stack memory associated with local variable 'd' is returned}} \
+ // expected-note {{returned here}}
+}
+
+const int &dangling_abbreviated_explicit_object() {
+ Deduced d;
+ return d.get_auto(); // expected-warning {{stack memory associated with local variable 'd' is returned}} \
+ // expected-note {{returned here}}
+}
+
+const int &dangling_prvalue_deduced_explicit_object() {
+ return Deduced{}.get(); // expected-warning {{stack memory associated with temporary object is returned}} \
+ // expected-note {{returned here}}
+}
+
+const int &deduced_explicit_object_param(const Deduced &d) { return d.get(); }
+
+// The object-argument heuristics apply to an explicit object parameter too.
+struct [[gsl::Owner]] Buffer {};
+struct [[gsl::Pointer]] BufferView {
+ BufferView(const Buffer &b [[clang::lifetimebound]]);
+ int *get(this const BufferView &self);
+ int &operator*(this const BufferView &self);
+};
+struct [[gsl::Pointer]] ValueView {
+ ValueView(const Buffer &b [[clang::lifetimebound]]);
+ int *get(this ValueView self);
+};
+struct [[gsl::Pointer]] TextView {
+ const char *p;
+};
+struct [[gsl::Owner]] Text {
+ operator TextView(this const Text &self);
+};
+struct Assignable {
+ Assignable &operator=(this Assignable &self, const Assignable &other);
+};
+
+int *get_through_explicit_object() {
+ Buffer b;
+ BufferView w(b); // expected-warning {{stack memory associated with local variable 'b' is returned}}
+ return w.get(); // expected-note {{returned here}}
+}
+
+int *deref_through_explicit_object() {
+ Buffer b;
+ BufferView w(b); // expected-warning {{stack memory associated with local variable 'b' is returned}}
+ return &*w; // expected-note {{result of call to 'operator*' aliases the storage of local variable 'b'}} \
+ // expected-note {{returned here}}
+}
+
+int *get_through_by_value_explicit_object() {
+ Buffer b;
+ ValueView w(b); // expected-warning {{stack memory associated with local variable 'b' is returned}}
+ return w.get(); // expected-note {{returned here}}
+}
+
+TextView convert_through_explicit_object() {
+ Text t;
+ return t; // expected-warning {{stack memory associated with local variable 't' is returned}} \
+ // expected-note {{returned here}}
+}
+
+Assignable &assign_through_explicit_object() {
+ Assignable a;
+ return a = Assignable(); // expected-warning {{stack memory associated with local variable 'a' is returned}} \
+ // expected-note {{returned here}}
+}
+
+int *get_through_explicit_object_ok(const Buffer &b) {
+ BufferView w(b);
+ return w.get();
+}
+
+struct Sink {
+ void take(this Sink &self, std::string &&s);
+};
+
+std::string_view moved_after_explicit_object(Sink &sink) {
+ std::string s;
+ std::string_view v = s; // expected-warning {{stack memory associated with local variable 's' may be returned later}}
+ sink.take(std::move(s)); // expected-note {{potentially moved here}}
+ return v; // expected-note {{returned here}}
+}
More information about the cfe-commits
mailing list